• Spring是一个主流的Javaweb 开发框架，该框架是一个轻量级的业务层框架，具有很高的凝聚力和吸引力
  • Spring是分层的Java SE 轻量级开源框架，它是以IOC（Inverse of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为为内核，使用基本的 JavaBean 完成以前只可能由 EJB 完成的工作，取代了 EJB 臃肿和低效的开发模式。
  • Spring是一个开源容器框架，它集成各类型的工具，通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。
  • Spring致力于提供一种方法管理你的业务对象。
  • Rod Johnson对Java EE系统框架的臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求革新的探索之道，于是他编写了interface 21框架，力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。
  • Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。
  • 轻量：从大小和开销来说，Spring框架都是轻量的。
  • 控制反转：Spring通过一种称作控制反转（IoC）的技术促进了低耦合。当应用了IOC，一个对象所依赖的其他对象就会被动的传递进来，而并不是这个对象主动地查找依赖对象或者创建对象。
  • 面向切面编程：Spring提供了面向切面编程，它将其业务逻辑与系统级服务分离开来进行内聚性的开发。也就是说它仅仅只负责完成业务逻辑，并不复杂其他系统级关注点。
  • 方便集成各种优秀框架：Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。
  • 容器：Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器。

  • Spring Core：是框架最基础的部分，它提供依赖（Dependency Injection）注入来管理Bean容器功能。
  • Spring Context：构建于Core包上，提供了一种框架式访问对象的方式，有些像JNDI注册。
  • Spring DAO：提供了JDBC的抽象层，可消除冗长的JDBC编码和管理议程处理和不同数据供应商抛出的议程错误信息。
  • Spring ORM：ORM模块提供对常用的ORM框架的管理和辅助支持。
  • Spring Web：Web模块提供对常见框架如Struts1，WEBWORK（Struts 2），JSF的支持，Spring能够管理这些框架，将Spring的资源注入给框架，也能在这些框架的前后插入拦截器。
  • Spring AOP：AOP包提供了符合AOP Alliance规范的面向方面的编程实现，例如方法拦截器（method-interceptors）和切点（pointcuts），从逻辑上讲，从而减弱代码的功能耦合，清晰的被分离开。
  • Spring MVC： Spring 的MVC 框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol。

控制反转其实是一种设计思想，他将原本在程序员手中的控制权反转给了用户。将其程序自动创建对象的权利变成了程序被动接受用户传入的参数。

实例：

  • 没反转前：程序主动创建对象
  1.     public class Userserviceimpl implements Userservice{
  2.     @Override
  3.     public void getUser() {
  4.         new Userdaoimpl().getname();
  5.     }
  6. }
  • 反转后：程序被动接受对象
  1. public class Userserviceimpl implements Userservice{
  2.     private Userdao userdao;
  4.     public void setUserdao(Userdao userdao) {
  5.         this.userdao = userdao;
  6.     }
  7.     @Override
  8.     public void getUser() {
  9.         userdao.getname();
  10.     }
  11. }

小结：

  • 控制反转是一种描述XML或者注解，并通过去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，但其实现的方法是依赖注入。个人觉得控制反转就是获取依赖对象的方式反转了，从而达到了低耦合。
  • 实体类-Hello.class
  1. package com.lee.pojo;
  3. public class Hello {
  4.     private String Str;
  6.     public void setStr(String str) {
  7.         Str = str;
  8.     }
  10.     public String getStr() {
  11.         return Str;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Hello{" +
  17.                 "Str='" + Str + '\'' +
  18.                 '}';
  19.     }
  20. }
  • 配置元数据-beans.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="hello" class="com.lee.pojo.Hello">
  7.         <property name="str" value="Spring"/>
  8.     </bean>
  9. </beans>
  • 测试类-MyTest.class
  1. package com.lee;
  3. import com.lee.pojo.Hello;
  4. import org.junit.Test;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. public class MyTest {
  8.     public static void main(String[] args) {
  9.         //获取spring上下文对象
  10.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  11.         //我们的对象现在都在spring中管理了，我们只需要从中取出来即可
  12.         Hello hello = (Hello) context.getBean("hello");
  13.         System.out.println(hello.toString());
  14.     }
  15. }

1.使用无参构造创建对象（默认）
2.使用有参构造创建对象

  • 下标赋值
  1.     <bean id="hello" class="com.lee.pojo.Hello">
  2.         <!--下标赋值-->
  3.         <constructor-arg index="0" value="老李"/>
  4.     </bean>
  • 类型赋值
  1.         <bean id="hello" class="com.lee.pojo.Hello">
  2.             <constructor-arg type="java.lang.String" value="老李"/>
  3.         </bean>
  • 参数名赋值
  1.     <bean id="hello" class="com.lee.pojo.Hello">
  2.         <constructor-arg name="Str" value="老李"/>
  3.     </bean>
  • 别名
  1. <!--通过alias起别名-->
  2.     <bean id="hello" class="com.lee.pojo.Hello">
  3.         <constructor-arg name="Str" value="老李"/>
  4.     </bean>
  5.     <alias name="hello" alias="hello2"/>
  • beans的配置
  1. <!--
  2. 1.name也可以起别名，而且能起多个
  3. 2.id:bean的唯一标识，相当于我们的对象名
  4. 3.class：对象所对应的全限定名
  5. -->
  6. ```xml
  7.     <bean id="hello" class="com.lee.pojo.Hello" name="hello3,hello4">
  8.         <constructor-arg name="Str" value="老李"/>
  9.     </bean>
  • import
    import一般用于团队开发使用，它可以将多个配置文件导入合并为一个,使用的时候我们直接使用总配置就可以了。
  1.     <import resource="beans1.xml"/>
  2.     <import resource="beans2.xml"/>
  3.     <import resource="beans3.xml"/>

依赖：bean对象的创建依赖于容器
注入：bean对象的所有属性由容器来注入

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="address" class="com.lee.pojo.Address"/>
  7.     <bean id="student" class="com.lee.pojo.Student">
  8.         <!--1.普通值注入-->
  9.         <property name="name" value="李好"/>
  10.         <!--2.bean注入-->
  11.         <property name="address" ref="address"/>
  12.         <!--3.数组注入-->
  13.         <property name="books">
  14.             <array>
  15.                 <value>水浒传</value>
  16.                 <value>三国演义</value>
  17.                 <value>红楼梦</value>
  18.                 <value>西游记</value>
  19.             </array>
  20.         </property>
  21.         <!--4.列表注入-->
  22.         <property name="hobby">
  23.             <list>
  24.                 <value>看书</value>
  25.                 <value>跳舞</value>
  26.                 <value>放屁</value>
  27.             </list>
  28.         </property>
  29.         <!--5.map注入-->
  30.         <property name="card">
  31.             <map>
  32.                 <entry key="身份证" value="123456"/>
  33.                 <entry key="银行卡" value="654321"/>
  34.             </map>
  35.         </property>
  36.         <!--6.Set注入-->
  37.         <property name="game">
  38.             <set>
  39.                 <value>LOL</value>
  40.             </set>
  41.         </property>
  42.         <!--7.空值注入-->
  43.         <property name="wife">
  44.             <null/>
  45.         </property>
  46.         <!--8.properties-->
  47.         <property name="info">
  48.             <props>
  49.                 <prop key="学号">200822222</prop>
  50.             </props>
  51.         </property>
  52.     </bean>
  53. </beans>

实例：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:p="http://www.springframework.org/schema/p"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  8.     <bean id="user" class="com.lee.pojo.User" p:name="老李" p:age="18"/>
  10. </beans>


重点掌握前两个！！

  1. 单例模式（singleton）
  1. <bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

当您定义一个bean定义并且其作用域为单例时，Spring IoC容器将为该bean定义的对象创建一个实例。该单个实例存储在此类单例bean的高速缓存中，并且对该命名bean的所有后续请求和引用都返回该高速缓存的对象。通俗来说就是每一次请求容器返回的对象都是同一个对象。

2.原型模式
每次从容器中get都会产生一个新对象

  1. <bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

ByName自动装配

  1.     <bean id="cat" class="com.lee.pojo.Cat"/>
  2.     <bean id="dog" class="com.lee.pojo.Dog"/>
  3.     <bean id="people" class="com.lee.pojo.People" autowire="byName"> <!--byname：会自动在容器中查找和
  4.                                                                         自己对象set方法后面的值d对应的bean id-->
  6.         <property name="name" value="老李"/>
  7. <!--手动装配-->
  8. <!--        <property name="cat" ref="cat"/>-->
  9. <!--        <property name="dog" ref="dog"/>-->
  10.     </bean>

Bytype自动装配

  1.     <bean id="cat" class="com.lee.pojo.Cat"/>
  2.     <bean id="dog" class="com.lee.pojo.Dog"/>
  3.     <bean id="people" class="com.lee.pojo.People" autowire="bytype"> <!--byname：会自动在容器中查找和
  4.                                                                         自己对象属性类型对应的bean-->
  6.         <property name="name" value="老李"/>
  7. <!--手动装配-->
  8. <!--        <property name="cat" ref="cat"/>-->
  9. <!--        <property name="dog" ref="dog"/>-->
  10.     </bean>

小结：

  • byname的时候，需要保证所有的bean id唯一，并且这个bean需要和主动注入的属性的set方法的值一致。
  • byname的时候，需要保证所有的bean的class唯一，并且这个bean需要和主动注入的属性一致。

1.导入约束：context约束

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         https://www.springframework.org/schema/beans/spring-context.xsd
  10.         http://www.springframework.org/schema/aop
  11.         https://www.springframework.org/schema/beans/spring-aop.xsd">
  13.     <!--开启注解的支持-->
  14.     <context:annotation-config/>
  15.     <bean id="cat" class="com.lee.pojo.Cat"/>
  16.     <bean id="dog" class="com.lee.pojo.Dog"/>
  17.     <bean id="people" class="com.lee.pojo.People"/>
  18. </beans>

2.配置注解支持：context:annotation-config/

3.小结

  • 直接在属性上使用@Autowired即可。
  • 使用Autowired注解我们可以不用使用set方法，但前提是这个自动装配的属性在IOC容器内，且符合byname。
  • 如果@Autowired的环境比较复杂，自动装配无法通过一个注解完成的时候，我们可以使用@Qualifier来配合其使用，指定唯一一个bean注入。
  1.     private String name;
  2.     @Autowired
  3.     @Qualifier(value = "dog111")
  4.     private Dog dog;
  5.     
  6.     @Autowired
  7.     @Qualifier(value = "cat111")
  8.     private Cat cat;

为什么要学代理模式？ 因为这就是Spring AOP的底层

代理模式的分类：

  • 静态代理
  • 动态代理

角色分析

  • 抽象角色：一般使用接口或者抽象类来解决
  1. package com.lee.pojo;
  3. public interface Rent {
  4.     public void rent();
  5. }
  • 真实角色：被代理的角色
  1. package com.lee.pojo;
  3. public class Host implements Rent{
  4.     @Override
  5.     public void rent() {
  6.         System.out.println("我的房屋要出租！");
  7.     }
  8. }
  • 代理角色：代理真实角色，一般都会加一些附属操作
  1. package com.lee.pojo;
  3. public class Proxy implements Rent{
  5.     private Host host;
  7.     public Proxy(Host host) {
  8.         this.host = host;
  9.     }
  11.     @Override
  12.     public void rent() {
  13.         host.rent();
  14.         seehouse();
  15.         fare();
  16.     }
  17.     public void seehouse(){
  18.         System.out.println("看房！");
  19.     }
  20.     public void fare(){
  21.         System.out.println("收取中介费！");
  22.     }
  23. }
  • 客户：访问代理对象的人
  1. package com.lee.pojo;
  3. public class Client {
  4.     public static void main(String[] args) {
  5.         Host host = new Host();
  6.         Proxy proxy = new Proxy(host);
  7.         proxy.rent();
  8.     }
  9. }

分类

  • 基于接口的动态代理—JDK动态代理
  • 基于类的动态代理—cglib
  • aop意为面向切面编程，通过预编译的模式或者运行期间动态代理实现程序功能的统一维护的一种功能。
  • 提供声明式事务，允许用户自定义切面
    {{evernotecid://9DC01347-8905-4315-8627-6E807F22CB57/appyinxiangcom/31529419/ENResource/p110(uploading…)}}

使用原生spring API接口（主要是spring API接口实现）

  1. 导入AOP依赖包
  1. <dependency>
  2.             <groupId>org.aspectj</groupId>
  3.             <artifactId>aspectjweaver</artifactId>
  4.             <version>1.9.4</version>
  5.         </dependency>
  1. applicationCtext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:p="http://www.springframework.org/schema/p"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/aop
  9.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  11.     <bean id="userservice" class="com.lee.Service.Userservice"/>
  12.     <bean id="afterlog" class="com.lee.Log.Afterlog"/>
  13.     <bean id="firstlog" class="com.lee.Log.Firstlog"/>
  15.     <!--配置AOP-->
  16.     <aop:config>
  17.         <!--切入点-->
  18.         <aop:pointcut id="pointcut" expression="execution(* com.lee.Service.Userservice.*(..))"/>
  19.         <aop:advisor advice-ref="firstlog" pointcut-ref="pointcut"/>
  20.         <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
  24.     </aop:config>
  25. </beans>

3.firstlog.java

  1. package com.lee.Log;
  3. import org.springframework.aop.MethodBeforeAdvice;
  5. import java.lang.reflect.Method;
  7. public class Firstlog implements MethodBeforeAdvice {
  8.     @Override
  9.     public void before(Method method, Object[] objects, Object o) throws Throwable {
  10.         System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了！");
  11.     }
  12. }

4.afterlog.java

  1. package com.lee.Log;
  3. import org.springframework.aop.AfterReturningAdvice;
  5. import java.lang.reflect.Method;
  7. public class Afterlog implements AfterReturningAdvice {
  8.     @Override
  9.     public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
  10.         System.out.println("执行了"+method.getName()+"，结果为"+o);
  11.     }
  12. }

使用自定义类(主要是切面定义)

  1. 自定义类
  1. package com.lee.diy;
  3. public class DiypointCut {
  4.     public void before(){
  5.         System.out.println("执行前！");
  6.     }
  7.     public void after(){
  8.         System.out.println("执行后！！");
  9.     }
  10. }
  1. applicationCtext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:p="http://www.springframework.org/schema/p"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/aop
  9.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  11.     <bean id="userservice" class="com.lee.Service.Userservice"/>
  12.     <bean id="afterlog" class="com.lee.Log.Afterlog"/>
  13.     <bean id="firstlog" class="com.lee.Log.Firstlog"/>
  14.     <bean id="diy" class="com.lee.diy.DiypointCut"/>
  15.     <!--配置AOP-->
  16.     <aop:config>
  17.         <!--切入点-->
  18. <!--        <aop:pointcut id="pointcut" expression="execution(* com.lee.Service.Userservice.*(..))"/>-->
  19. <!--        <aop:advisor advice-ref="firstlog" pointcut-ref="pointcut"/>-->
  20. <!--        <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>-->
  22.         <aop:aspect ref="diy">
  23.             <aop:pointcut id="diyy" expression="execution(* com.lee.Service.Userservice.*(..))"/>
  24.             <aop:before method="before" pointcut-ref="diyy"/>
  25.             <aop:after method="after" pointcut-ref="diyy"/>
  26.         </aop:aspect>
  29.     </aop:config>
  30. </beans>

版权声明：本文为Jeson-Sun原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Jeson-Sun/p/14506456.html