Spring学习笔记

Spring

1.0 Spring 概述

Spring : 春天 —>给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

优点

1. Spring是一个开源免费的框架
2. Spring是一个轻量级的框架，非侵入式的
3. 控制反转 IOC ,面向切面 AOP
4. 对事物的支持，对框架的支持

Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器。

2.0 Spring的体系组成（结构）

• 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
• Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
• Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
• Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
• Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
• Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
• Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

3.0 IOC（控制反转）

IOC 本质

控制反转IOC 是一种设计思想，DI（依赖注入）是实现IOC的一种方法。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

4.0 第一个Spring程序

导入依赖

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

编写一个Hello实体类

public class Hello {
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

编写Spring的配置文件 beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>

</beans>

测试

@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

5.0 IOC 创建对象的方式

1. 通过无参构造创建

//User实体

public class User {

   private String name;

   public User() {
       System.out.println("user无参构造方法");
  }

   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("name="+ name );
  }

}

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="user" class="com.kuang.pojo.User">
       <property name="name" value="kuangshen"/>
   </bean>

</beans>

测试

@Test
public void test(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //在执行getBean的时候, user已经创建好了 , 通过无参构造
   User user = (User) context.getBean("user");
   //调用对象的方法 .
   user.show();
}

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

2. 通过有参构造创建

public class UserT {

   private String name;

   public UserT(String name) {
       this.name = name;
  }

   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("name="+ name );
  }

}

beans.xml

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="kuangshen2"/>
</bean>


<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kuangshen2"/>
</bean>


<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>

测试

结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

6.0 Spring配置

别名

alias 设置别名，为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

7.0 依赖注入 （DI）

依赖注入两种方式 Set注入、构造器注入

Set注入

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

Address.java

 public class Address {
 
     private String address;
 
     public String getAddress() {
         return address;
    }
 
     public void setAddress(String address) {
         this.address = address;
    }
 }

Student.java

public class Student {
 
     private String name;
     private Address address;
     private String[] books;
     private List<String> hobbys;
     private Map<String,String> card;
     private Set<String> games;
     private String wife;
     private Properties info;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAddress(Address address) {
         this.address = address;
    }
 
     public void setBooks(String[] books) {
         this.books = books;
    }
 
     public void setHobbys(List<String> hobbys) {
         this.hobbys = hobbys;
    }
 
     public void setCard(Map<String, String> card) {
         this.card = card;
    }
 
     public void setGames(Set<String> games) {
         this.games = games;
    }
 
     public void setWife(String wife) {
         this.wife = wife;
    }
 
     public void setInfo(Properties info) {
         this.info = info;
    }
 
     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);
 
         System.out.println("card:"+card);
 
         System.out.println("games:"+games);
 
         System.out.println("wife:"+wife);
 
         System.out.println("info:"+info);
 
    }
 }

常量注入

 <bean id="student" class="com.yao.pojo.Student">
     <property name="name" value="小明"/>
 </bean>

Bean注入

注意点：这里的值是一个引用，ref

 <bean id="addr" class="com.yao.pojo.Address">
     <property name="address" value="重庆"/>
 </bean>
 
 <bean id="student" class="com.yao.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
 </bean>

数组注入

 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
     <property name="books">
         <array>
             <value>西游记</value>
             <value>红楼梦</value>
             <value>水浒传</value>
         </array>
     </property>
 </bean>

List 注入

 <property name="hobbys">
     <list>
         <value>听歌</value>
         <value>看电影</value>
         <value>爬山</value>
     </list>
 </property>

Set注入

 <property name="games">
     <set>
         <value>LOL</value>
         <value>BOB</value>
         <value>COC</value>
     </set>
 </property>

Map注入

 <property name="card">
     <map>
         <entry key="中国邮政" value="456456456465456"/>
         <entry key="建设" value="1456682255511"/>
     </map>
 </property>

Null注入

 <property name="wife"><null/></property>

Properties注入

 <property name="info">
     <props>
         <prop key="学号">20190604</prop>
         <prop key="性别">男</prop>
         <prop key="姓名">小明</prop>
     </props>
 </property>

P命名空间和C命名空间

User.java ：【注意：这里没有有参构造器！】

 public class User {
     private String name;
     private int age;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAge(int age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }

1、P命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:p="http://www.springframework.org/schema/p"
 
 <!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.yao.pojo.User" p:name="李白" p:age="18"/>

2、c 命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:c="http://www.springframework.org/schema/c"
 <!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.yao.pojo.User" c:name="李白" c:age="18"/>

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

测试

8.0 Bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fAXC5JJ7-1601190977433)(C:\Users\85477\AppData\Roaming\Typora\typora-user-images\image-20200926204216445.png)]

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

Singleton

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

9.0 Bean 的自动装配

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

1. 组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
2. 自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

新建两个实体类，Cat、Dog

public class Cat {
   public void shout() {
       System.out.println("miao~");
  }
}

public class Dog {
   public void shout() {
       System.out.println("wang~");
  }
}

新建一个用户 User

public class User {
   private Cat cat;
   private Dog dog;
   private String str;
}

编写Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

   <bean id="dog" class="com.yao.pojo.Dog"/>
   <bean id="cat" class="com.yao.pojo.Cat"/>

   <bean id="user" class="com.yao.pojo.User">
       <property name="cat" ref="cat"/>
       <property name="dog" ref="dog"/>
       <property name="str" value="张三"/>
   </bean>
</beans>

byName

autowire byName (按名称自动装配)

测试：

1、修改bean配置，增加一个属性 autowire=“byName”

<bean id="user" class="com.yao.pojo.User" autowire="byName">
   <property name="str" value="张三"/>
</bean>

2、再次测试，结果依旧成功输出！

3、我们将 cat 的bean id修改为 catXXX

4、再次测试， 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

1. 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
2. 去spring容器中寻找是否有此字符串名称id的对象。
3. 如果有，就取出注入；如果没有，就报空指针异常。

byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

测试：

1、将user的bean配置修改一下 ： autowire=“byType”

2、测试，正常输出

3、在注册一个cat 的bean对象！

<bean id="dog" class="com.yao.pojo.Dog"/>
<bean id="cat" class="com.yao.pojo.Cat"/>
<bean id="cat2" class="com.yao.pojo.Cat"/>

<bean id="user" class="com.yao.pojo.User" autowire="byType">
   <property name="str" value="张三"/>
</bean>

4、测试，报错：NoUniqueBeanDefinitionException

5、删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。

这就是按照类型自动装配！

使用注解

准备工作：利用注解的方式注入属性。

1、在spring配置文件中引入context文件头

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解支持！

<context:annotation-config/>

@Autowired

• @Autowired是按类型自动转配的，不支持id匹配。
• 需要导入 spring-aop的包！

测试

1、将User类中的set方法去掉，使用@Autowired注解

public class User {
    
   @Autowired
   private Cat cat;
    
   @Autowired
   private Dog dog;
   private String str;

   public Cat getCat() {
       return cat;
  }
   public Dog getDog() {
       return dog;
  }
   public String getStr() {
       return str;
  }
}

2、此时配置文件内容

<context:annotation-config/>

<bean id="dog" class="com.yao.pojo.Dog"/>
<bean id="cat" class="com.yao.pojo.Cat"/>
<bean id="user" class="com.yao.pojo.User"/>

3、测试，成功输出结果！

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

@Qualifier

• @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
• @Qualifier不能单独使用。

测试实验步骤：

1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.yao.pojo.Dog"/>
<bean id="dog2" class="com.yao.pojo.Dog"/>
<bean id="cat1" class="com.yao.pojo.Cat"/>
<bean id="cat2" class="com.yao.pojo.Cat"/>

2、没有加Qualifier测试，直接报错

3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

测试，成功输出！

@Resource

• @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
• 其次再进行默认的byName方式进行装配；
• 如果以上都不成功，则按byType的方式自动装配。
• 都不成功，则报异常。

实体类：

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

beans.xml

<bean id="dog" class="com.yao.pojo.Dog"/>
<bean id="cat1" class="com.yao.pojo.Cat"/>
<bean id="cat2" class="com.yao.pojo.Cat"/>

<bean id="user" class="com.yao.pojo.User"/>

测试

总结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

10.0 使用注解开发

Bean的实现

1、配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "张三";
}

3、测试

@Test
public void test(){
   ApplicationContext applicationContext =
       new ClassPathXmlApplicationContext("beans.xml");
   User user = (User) applicationContext.getBean("user");
   System.out.println(user.name);
}

属性注入

使用注解注入属性

1、可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("张三")
   // 相当于配置文件中 <property name="name" value="张三"/>
   public String name;
}

2、如果提供了set方法，在set方法上添加@value(“值”);

@Component("user")
public class User {

   public String name;

   @Value("张三")
   public void setName(String name) {
       this.name = name;
  }
}

衍生注解

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

• @Controller：web层
• @Service：service层
• @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

作用域

@Scop

@Controller("user")
@Scope("prototype")
public class User {
   @Value("张三")
   public String name;
}

基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。

测试：

1、编写一个实体类，Dog

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
   public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {

   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }

}

3、测试

@Test
public void test2(){
   ApplicationContext applicationContext =
           new AnnotationConfigApplicationContext(MyConfig.class);
   Dog dog = (Dog) applicationContext.getBean("dog");
   System.out.println(dog.name);
}

4、成功输出结果！

导入其他配置如何做呢？

1、我们再编写一个配置类！

@Configuration  //代表这是一个配置类
public class MyConfig2 {
}

2、在之前的配置类中我们来选择导入这个配置类

@Configuration
@Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {

   @Bean
   public Dog dog(){
       return new Dog();
  }

}

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

11.0 代理模式

代理模式：

• 静态代理 为每一个原始类，手工编写一个代理类 (.java .class)
• JDK动态代理
• Cglib动态代理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yRODKm5L-1601190977435)(C:\Users\85477\AppData\Roaming\Typora\typora-user-images\image-20200927125856164.png)]

以买房为例：

客户类(原始类)：卖家

接口（原始方法）：买房

代理类：中介

委托类：我们，买家

代理类，为原始类（目标）增加额外的功能
好处：利于原始类(目标)的维护

为什么使用代理模式？

· **中介隔离作用：**在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

· **开闭原则，增加功能：**代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

11.0.1 静态代理

原始类

public interface BuyHouse {

    //原始方法
    void BuyHouse();
}

实现类

public class BuyHouseImpl implements BuyHouse{

    public void buyHouse() {
        System.out.println("买家要买房");
    }
}

编写代理类

/**
 * 中介，也实现买房的接口，但是呢，他不会真正的买房子，
 * 真正买房子的方法还是买家执行
 * 中介中，持有买家的引用（属性）
 *
 * 中介：代理对象
 * 买家：被代理对象，目标对象
 *
 * 动态代理，不需要写代理类
 */
public class BuyHouseProxy implements BuyHouse{

    //中介持有买家的引用
    private BuyHouse maijia = new BuyHouseImpl();

    public void buyHouse() {
        System.out.println("买房前的工作");
        //由买家执行的，买家的buyHouse方法称为目标方法
        maijia.buyHouse();
        System.out.println("买房后的工作");

测试

public class Test1 {
    public static void main(String[] args) {
        //创建买房对象，代理对象
        BuyHouse proxy = new BuyHouseProxy();
        //代理对象调用买房的方法
        proxy.buyHouse();
    }
}

如果我们把买房前的工作和买房后的工作封装在方法中的话，可以写一个工具类，专门存放附加的方法：

/**
 * 买房的附加功能,由代理做的
 */
public class BuyHouseUtils {

    public static void before(){
        System.out.println("买房前做的工作");
    }

    public static void after(){
        System.out.println("买房后做的工作");
    }
}

这样，代理中的代码修改为：

public class BuyHouseProxy implements BuyHouse{

    //中介持有买家的引用
    private BuyHouse maijia = new BuyHouseImpl();

    public void buyHouse() {
        BuyHouseUtils.before();
        //由买家执行的，买家的buyHouse方法称为目标方法
        maijia.buyHouse();
        BuyHouseUtils.after();
    }

总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

**缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。 **

11.0.2 JDK 动态代理 （基于接口）

在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

/** 
在程序运行的过程中，jdk动态生成代理对象，调用相应方法，实现功能
 * Proxy：类，代理类
 * Object static newProxyInstance:动态地生成代理对象。
 * 参数：ClassLoader：类的加载器，代理类接口的类加载器 BuyHouse.class.getClassLoader()
 *  Class<?>[] interfaces:代理类实现的接口列表（Class类型）BuyHouseImpl.class.getInterfaces()
 *  InvocationHandlder:处理器，接口，里面有个invoke方法，接口不能创建对象，可以写实现类，现在不写，以匿名内部类的形式去创建
 */




public class Test2 {
    public static void main(String[] args) {
        //创建被代理类的对象
        final BuyHouse target = new BuyHouseImpl();
        //方法的返回值就是代理对象
        BuyHouse proxy = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), BuyHouseImpl.class.getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //该方法就相当于咱们创建代理类，重写buyHouse方法，
                //proxy：代理对象
                //method:要调用的目标方法，买家的buyHouse方法
                //args：执行目标方法需要的参数
                //该方法的返回值，就是目标方法的返回值
                //最终是让目标方法执行，反射的形式，第一个参数是对象，哪个对象的方法，目标对象（买家）
                //匿名内部类中调用局部变量，被final修饰，
                //在执行目标方法之前去执行增强的操作
                BuyHouseUtils.before();
                Object result = method.invoke(target, args);
                //在执行目标方法之后去执行增强的操作
                BuyHouseUtils.after();
                //返回结果
                return result;
            }
        });

        //代理对象调用方法
        proxy.buyHouse();
    }
}

测试

*Proxy.newProxyInstance()*方法接受三个参数：

· ClassLoader loader*:*指定当前目标对象使用的类加载器,获取加载器的方法是固定的

· Class<?>[] interfaces*:*指定目标对象实现的接口的类型,使用泛型方式确认类型

· InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法

虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫Proxy。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理，原因是多继承在Java中本质上就行不通。有很多条理由，人们可以否定对 class代理的必要性，但是同样有一些理由，相信支持class动态代理会更美好。接口和类的划分，本就不是很明显，只是到了Java中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。但是，不完美并不等于不伟大，伟大是一种本质，Java动态代理就是佐例。

11.0.3 Cglib 动态代理 （基于类）

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

导入CGLIB包，maven中导入spring-aspects坐标，就包含了cglib包了

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.19.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.19.RELEASE</version>
</dependency>

编写BuyHouse类

public class BuyHouse {
    
    public void buyHouse(){
        System.out.println("买家要买房子");
    }
}

Cglib 动态代理

//        创建原始类对象
pojo.BuyHouse  buyHouse= new pojo.BuyHouse();
//        创建Enhancer 对象
Enhancer enhancer = new Enhancer();
//        创建父类。本质是创建子类
enhancer.setSuperclass(buyHouse.getClass());
//        设置回调,方法拦截器
enhancer.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //拦截的方法
        //参数 o：目标对象
        //method:目标方法
        //objects：执行方法的参数
        //MethodProxy：方法的代理对象
        BuyHouseUtils.before();
        Object invoke = methodProxy.invoke(buyHouse, objects);
        BuyHouseUtils.after();
        return invoke;
    }
});

//        生成代理对象
pojo.BuyHouse proxy = (pojo.BuyHouse) enhancer.create();
//        调用原始方法
proxy.buyHouse();

    }

CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

12.0 AOP

12.0.1 AOP介绍

Aspect-Oriented Programming (AOP)，切面编程

AOP与OOP(Object-Oriented Programming)编程模式不同，提供了一种不同的编程思想。

Spring IOC容器不依赖AOP，如果不需要可以不导入AOP相关包。

Spring AOP提供了两种模式：

• 基于XML的模式
• 基于@AspectJ注解模式

基于Spring的AOP，重要应用有：

• 用AOP声明性事务代替EJB的企业服务
• 用AOP做日志处理
• 用AOP做权限控制，如Spring Security

12.0.2 AOP术语

• 切面（Aspect）：模块化关注多个类的共性处理。事务管理是J2EE应用中一个关于横切关注的很好的例子。
• 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。
• 通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。
• 切入点（Pointcut）：它由切入点表达式和签名组成。切入点如何与连接点匹配是AOP的核心，Spring缺省使用AspectJ切入点语法。
• 引入（Introduction）：用来给一个类型声明，添加额外的方法或属性。Spring允许引入新的接口给任何被织入的对象。例如，你可以通过引入，使一个bean实现IsModified接口，以便简化缓存机制。
• 目标对象（Target Object）： 被一个或者多个切面所通知的对象。也被称做被通知对象。 既然Spring AOP是通过动态代理实现的，这个对象永远是一个被代理对象。
• AOP代理（AOP Proxy）：动态代理，在Spring中，AOP代理可以是JDK的Proxy或者CGLIB.
• 织入（Weaving）：创建一个通知者,把切面连接到其它的应用程序类型或者对象上。这些可以在编译时，类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

连接点：将要执行的目标方法

通知：我们写的增强的方法

advice的通知类型

• 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
• 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
• 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
• 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
• 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

12.0.3 AspectJ 入门案例

@AspectJ介绍

@AspectJ是一种风格样式，可以把Java的普通类，声明为一个切面。

导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

自动代理配置

<!--    开启注解支持-->
    <context:annotation-config/>
<!--    包扫描-->
    <context:component-scan base-package="com.aop"/>
    <context:component-scan base-package="com.yao"/>

<!--    开启自动代理-->
    <aop:aspectj-autoproxy/>

编写切面类

@Component   //创建对象，放入spring容器
@Aspect  //这是一个切面类
public class LoggingAop {

    @Pointcut("execution(public * com.yao.service.*.*(..))")
    public void serviceMethod(){}

    @Pointcut("execution(public * com.yao.dao.*.*(..))")
    public void daoMethod(){}


    @Before("serviceMethod() || daoMethod()")
    public void log(){
        System.out.println("=======log=======");
    }

编写service

@Service
public class UserService {

    public void login(){
        System.out.println("userService login.....");
    }

}

编写Dao

@Repository
public class UserDao {
    public void login(){
        System.out.println("userDao login.....");
    }
}

测试

@Test
public void test1(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/beans.xml");
    UserService userService = applicationContext.getBean(UserService.class);
    userService.login();

    UserDao userdao = applicationContext.getBean(UserDao.class);
    userdao.login();
}

12.0.4 基于XML的Aop配置

在Spring的配置文件中，所有的切面和通知都必须定义在aop:config元素内部（context可以包含多个 aop:config）。

一个aop:config可以包含pointcut，advisor和aspect元素 （注意这三个元素必须按照这个顺序进行声明）。

警告：

1、aop:config风格配置使得Spring的auto-proxying机制变得很笨重.

2、如果你已经通过 BeanNameAutoProxyCreator或类似的东西显式使用auto-proxying，它可能会导致问题 （例如通知没有被织入）。

3、推荐的使用模式是仅仅使用aop:config风格， 或者仅仅使用AutoProxyCreator风格。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m95nYxgN-1601190977436)(C:\Users\85477\AppData\Roaming\Typora\typora-user-images\image-20200927144528794.png)]

日志管理案例

创建UserService接口：

public interface UserService {

    public void login(String name, String pwd);
}

创建UserService的实现类：

@Service  
public class UserServiceImpl implements UserService {
    @Autowired   
    private UserDao userDao;     
    public void login(String name, String pwd) {     
        userDao.login(name,pwd);   
    } 
}

创建UserDao接扣：

public interface UserDao {     
    public void login(String name,String pwd);
}

UserDao的实现类：

@Repository  
public class UserDaoImpl implements UserDao {     
    public void login(String name,String pwd) {     
        if("admin".equals(name) && "123".equals(pwd)){       
            System.out.println("登录成功");     
        }else{       
            System.out.println("登录失败");     
        }   
    } 
}

编写loggingAspect的切面类：

/**
 * 切面类，1.需要创建对象，放在容器中， <bean></> or  @Component注解
 * 在切面类中写通知,只要写方法
 * 需要先放到容器中，再指定是一个切面
 */
//@Component("loggingAspectBean")
public class loggingAspect {

    //前置通知
    public void loggingBefore(){
        System.out.println("前置通知，"+ new Date());
    }

    //后置返回通知
    public void loggingAfterReturning(){
        System.out.println("后置返回通知，" + new Date());
    }

    //异常通知
    public void loggingAfterThrowing(){
        System.out.println("异常通知，"+ new Date());
    }

    //最终通知
    public void loggingAfter(){
        System.out.println("最终通知，" + new Date());
    }

    //环绕通知，一定要给一个参数，不给会影响目标方法的执行
    public Object loggingAround(ProceedingJoinPoint pjp){

        Object result = null;
        try {
            System.out.println("环绕通知，拦截之前执行的部分，"+ new Date());
            result = pjp.proceed();
            System.out.println("环绕通知，拦截之后执行的部分，" + new Date());
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return result;
    }
}

编写配置文件：

<!-- 开启组件扫描   -->
    <context:component-scan base-package="com.icss.service"></context:component-scan>
    <context:component-scan base-package="com.icss.dao"></context:component-scan>

    <!-- aop配置,切入点和切面，切面里面有通知  -->
    <aop:config>
        <!-- 配置切入点:签名，表达式
               id：签名，唯一标志，通过id引用某个切入点
               expression:表达式，跟之前一样写
               在aspect中也可以声明切入点，但是，在aspect中声明的切入点，只能在当前aspect中使用
               在config中声明的切入点，在任意的aspect中都可以使用
               expression：也可以联合使用切入点
        -->
        <aop:pointcut id="businessService" expression="execution(public * com.icss.service..*.*(..))"/>
        <aop:pointcut id="dataAccessOperate" expression="execution(public * com.icss.dao..*.*(..))"/>
        <!--  配置切面
              id：切面的唯一标志
              ref:支撑对象，容器中的对象
              首先要有对象，接着再把该对象声明为切面
        -->
        <aop:aspect id="loggingAspect" ref="loggingAspectBean">
            <!--  声明通知
                   method:指定通知方法，哪一个方法设置为前置通知
                   pointcut:指定切入点，直接写表达式，声明的时候，可以联合使用切入点
                   pointcut-ref:引用已经写好的切入点,不能联合使用切入点
            -->
<!--            <aop:before method="loggingBefore" pointcut-ref="businessService || dataAccessOperate"></aop:before>-->
            <aop:before method="loggingBefore" pointcut="execution(public * com.icss.service..*.*(..)) or execution(public * com.icss.dao..*.*(..))"></aop:before>
            <!-- 后置返回通知      -->
            <aop:after-returning method="loggingAfterReturning" pointcut-ref="businessService"></aop:after-returning>
            <!--   异常通知         -->
            <aop:after-throwing method="loggingAfterThrowing" pointcut-ref="businessService"></aop:after-throwing>
            <!--    最终通知        -->
            <aop:after method="loggingAfter" pointcut-ref="businessService"></aop:after>
            <!--       环绕通知    -->
            <aop:around method="loggingAround" pointcut-ref="businessService"></aop:around>
        </aop:aspect>
    </aop:config>
    <!--  切面的支撑对象  -->
    <bean id="loggingAspectBean" class="com.icss.aop.loggingAspect"></bean> 
</beans>

编写测试类

//获取容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
//获取UserService
UserService userService = ctx.getBean(UserService.class);
//调用登录方式
userService.login("admin","123");

13.0 声明式事务

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID

1. 原子性（atomicity）

2. • 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用

3. 一致性（consistency）

4. • 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中

5. 隔离性（isolation）

6. • 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏

7. 持久性（durability）

8. • 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

Spring 中的事务管理

编程式事务管理

• 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
• 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

• 一般情况下比编程式事务好用。
• 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
• 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

JDBC事务

<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource" />
</bean>

配置好事务管理器后我们需要去配置事务的通知

<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
   <tx:attributes>
       <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
       <tx:method name="add" propagation="REQUIRED"/>
       <tx:method name="delete" propagation="REQUIRED"/>
       <tx:method name="update" propagation="REQUIRED"/>
       <tx:method name="search*" propagation="REQUIRED"/>
       <tx:method name="get" read-only="true"/>
       <tx:method name="*" propagation="REQUIRED"/>
   </tx:attributes>
</tx:advice>

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

• propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
• propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
• propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
• propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
• propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
• propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
• propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。