超详细！！Spring5框架开发笔记

Spring5开发教程

简介

spring特性

• sping是轻量级的开源的JavaEE框架

• Spring可以解决企业应用开发的复杂性

• Sping两个核心的部分：IOC和AOC

  IOC：控制反转。把创建对象的过程交给sping进行管理，而不需要自己去new

  AOP：面向切面。不修改源代码进行功能增强

• Sping特点

  方便接耦，简化开发。

  AOP编程支持

  方便程序的测试

  方便集成各种优秀框架

  方便进行事务操作

  降低API开发难度

简单使用

如果使用maven构建项目，导入spring核心依赖包就可以了：

<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.8.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.8.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.8.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.2.8.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
  </dependency>
</dependencies>

随便创建一个User类，然后创建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">

    <!--配置User对象创建-->
    <bean id="user" class="com.atguigu.spring5.User"></bean>
</beans>

class是类路径

编写测试代码

public class TestSpring5 {

    @Test
    public void testAdd(){
        //1 加载spring配置文件
        ApplicationContext context = new FileSystemXmlApplicationContext("/src/main/java/bean1.xml"); //方式1
              //BeanFactory context = new FileSystemXmlApplicationContext("/src/main/java/bean1.xml");//方式2
        //2 获取配置创建的对象
        User user = context.getBean("user",User.class);

        System.out.println(user);
        user.add();
    }
}

此时，配置文件已经帮我们创建好了实例，我们直接从配置文件中获取就行了。

Spring IOC容器

IOC底层原理

什么是IOC

Inversion Of Control（控制反转）。把对象创建和对象之间的调用过程，交给Spring管理；使用IOC的目的是为了降低耦合度。

IOC底层主要用到三个技术：xml解析、工厂模式、反射。

• 工厂模式其实就把把对象的创建交给第三方，降低耦合度（完全没有耦合度是不能的）

  class UserService{
  	execute(){
  		UserDao dao = new UserFactory.getDao();
  	}
  }
  
  class UserDao{
  	...
  }
  
  class UserFactory{
  	public static UserDao getDao(){
  		return new UserDao();
  	}
  }
  

• 反射就是java代码可以动态获取类的字节码文件，从而可以得到类的属性和方法等。

IOC过程

1. xml配置文件，配置创建的对象

2. 有service类，dao类，创建工厂类

   class UserFactory{
   	public static UserDao getDao(){
   		String classValue = class属性值 //1 xml解析
   		Class class = Class.forName(classValue);//2 通过反射创建对象
   		return (UserDao) class.newInstance();
   	}
   }
   

IOC接口

• IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。

• Spring提供IOC容器实现两种方式：（两个接口）

  1. BeanFactory：IOC容器最基本实现，是Spring内部的使用接口，不提供开发人员进行使用

     *加载配置文件的时候不会创建对象，在获取对象(getBean)才去擦黄建对象

  2. ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员使用

     *加载配置文件配置文件的时候就会把配置文件对象进行创建

     一般把耗时耗资源的过程交给服务器启动的时候去完成，所以ApplicationContext更合适。

IOC操作Bean管理——XML方式

Bean管理是Spring的两个操作：Spring创建对象；Spring注入属性（不需要写set方法，这里的属性可以是基本类型，也可以是类对象）。

Bean管理操作有两种方式：基于xml配置文件方式实现；基于注解方式实现。

基于xml方式

• 创建对象

  <bean id="user" class="com.atguigu.spring5.User"></bean>
  <!--
  ----------
  bean标签常用的属性
  *id：唯一标识
  *class：类全路径（包类路径）
  *name：作用和id一样，可以加特殊符号，目前已弃用
  ----------
  创建对象时候，默认也是执行无参构造方法
  ----------
  -->
  

• 注入属性—基本数据类型

  DI：依赖注入，就是注入属性。

  <bean id="user" class="com.atguigu.spring5.User">
    <!--  set方法注入属性：使用property完成属性注入 -->
    <property name="userName" value="xing"></property>
    <!--
    有参构造方法注入属性
    <constructor-arg name="userName" value="xing"></constructor-arg>
    -->
  </bean>
  

  使用p名称空间注入，可简化基于xml配置方式

  <!--xmlns:p="http://www.springframework.org/schema/p"-->
  <bean id="user" class="com.atguigu.spring5.User" p:userName="xing"></bean>
  

  xml注入其他属性

  <!-- 设置空值 -->
  <property name="userName">
  	<null></null>
  </property>
  
  <!-- 特殊符号如:<<>> -->
  <property name="userName">
  	<value><![CDATA[<<xing>>]]></value>
  </property>
  

• 注入属性—外部bean

  创建一个service和dao对象，其中service里面有一个dao作为属性

  public class UserService {
      //创建UserDao类型属性，生成set方法
      private UserDao userDao;
  
      public void setUserDao(UserDao userDao) {
          this.userDao = userDao;
      }
  
      public void add(){
          userDao.update();
      }
  }
  

  配置文件

  <!-- service和dao对象的创建-->
  <bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!-- 注入userDao对象
          name属性值：类里面属性名称
          ref属性：创建userDao对象bean标签id值
          -->
    <!-- set 方法注入属性-->
    <property name="userDao" ref="userDaoImpl"></property>
  </bean>
  <!-- userDao的创建class要指向实现类-->
  <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
  

• 注入属性—内部bean

  内部bean可以理解在一个bean里面嵌套定义另外一个bean，实际应用中，更常用外部bean，因为更加清晰。

  <bean id="userService" class="com.atguigu.spring5.service.UserService">
    <property name="userDao">
    	<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">
    </property>
  </bean>
  

• 注入属性—级联赋值

  级联赋值就是注入外部bean的时候，在外部bean里面赋值，比如：

  <bean id="userService" class="com.atguigu.spring5.service.UserService">
    <property name="userDao" ref="userDaoImpl"></property>
  </bean>
  
  <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">
    <property name="userDaoProperty" value="value"></property>
  </bean>
  

  还有一种方式：这种方式要在userService中设置userDaoImpl的set方法，因为userDaoImpl.userDaoProperty要通过set方法来获取

  <bean id="userService" class="com.atguigu.spring5.service.UserService">
    <property name="userDao" ref="userDaoImpl"></property>
    <property name="userDaoImpl.userDaoProperty" value="value2"></property>
  </bean>
  

• 注入属性—集合属性

  public class Stu {
      private String[] courses;
      private List<String> list;
      private Map<String,String> map;
  
      //对象list
      private List<Course> courseList;
      public void setCourses(String[] courses) {
          this.courses = courses;
      }
  
      public void setList(List<String> list) {
          this.list = list;
      }
  
      public void setMap(Map<String, String> map) {
          this.map = map;
      }
  
      public void setCourseList(List<Course> courseList) {
          this.courseList = courseList;
      }
  }
  

  <bean id="stu" class="com.atguigu.spring5.collection.Stu">
    <!-- 数组属性的注入 -->
    <property name="courses">
      <array>
        <value>java课程</value>
        <value>数据库标签</value>
      </array>
    </property>
    <!-- list类型属性注入 -->
    <property name="list">
      <list>
        <value>张三</value>
        <value>李四</value>
      </list>
    </property>
    <!-- map类型属性注入 -->
    <property name="map">
      <map>
        <entry key="Java" value="java"></entry>
      </map>
    </property>
    <!-- 注入对象list类型 -->
    <property name="courseList">
      <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
      </list>
    </property>
  </bean>
  <bean id="course1" class="com.atguigu.spring5.collection.Course">
    <property name="cname" value="Spring5框架"></property>
  </bean>
  <bean id="course2" class="com.atguigu.spring5.collection.Course">
    <property name="cname" value="Mybatis框架"></property>
  </bean>
  

  还可以把集合注入部分提取出来，方法是在spring配置文件中引入新的名称空间比如util，模版如下：

  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:util="http://www.springframework.org/schema/util"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/util http://www.springframework.org/schema/utils/spring-utils.xsd">
  
      <!-- 提取list集合类型属性注入 -->
      <util:list id="bookList">
          <value>java</value>
          <value>c++</value>
      </util:list>
  
      <bean id="book" class="com.atguigu.spring5.collection.Book">
          <property name="list" ref="bookList"></property>
      </bean>
  </beans>
  

FactoryBean

Spring有两种类型的bean，一种普通bean，另一种工厂bean（FactoryBean）。

普通bean在Spring配置文件中定义什么类型，返回就是什么类型；而工厂bean定义的类型和返回的类型可以不一致。

做法：

• 创建类，让这个类作为工厂bean，实现接口FactoryBean

• 实现接口里面的方法，在实现的方法中定义返回的bean类型

  public class MyBean implements FactoryBean<Course> {
      //定义返回bean
      public Course getObject() throws Exception {
          Course course = new Course();
          course.setCname("java");
          return course;
      }
  
      public Class<?> getObjectType() {
          return null;
      }
  }
  

  <bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
  

  public class TestSpring5 {
      ApplicationContext context = new FileSystemXmlApplicationContext("/src/main/java/bean1.xml");
      Course course = context.getBean("myBean",Course.class);
  }
  

Bean的作用域

bean的作用域是指：在Spring里面，设置创建bean实例是单实例还是多实例（每次getBean都获取新对象），默认情况下是单实例对象。

在bean标签里面scope属性用来设置单实例还是多实例，默认值singleton，prototype表示多实例。

两个值的区别：singleton时候，加载spring配置文件时候就会创建单实例对象，而prototype在调用getBean方法时候才会去创建。

Bean的生命周期

1. 通过构造器创建bean实例（无参数构造）
2. 为bean的属性设置值和对其他bean引用（调用set方法）
3. *把bean实例传递bean后置处理器（实现BeanPostProcessor的类对象）的方法
4. 调用bean的初始化方法（需要配置初始化的方法 bean标签的init-method属性）
5. *把bean实例传递bean后置处理器的方法
6. bean可以使用了（对象获取到了）
7. 当容器关闭的时候（context.close()），调用bean的销毁方法（需要配置销毁的方法 bean标签的destroy-method属性）

xml自动装配

根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

<!--
     bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName：根据属性名称注入，注入bean的id值和类属性名称一样
        byType：根据属性类型注入，相同类型的bean不能有多个
    -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

基于xml的自动装配很少用到，基本都是使用注解

引入外部属性文件

以配置数据库连接池为例：

1. 创建外部属性文件.properties格式文件，写数据库信息

   prop.driverClass=com.mysql.jdbc.Driver
   prop.url=jdbc:mysql://localhost:3306/userDb
   prop.userName=root
   prop.passWord=root
   #等号左边可以随便写，但建议不要写某一个单词，容易冲突
   

2. 把外部properties属性文件引入到spring配置文件中

   首先引入context名称空间，先后在spring配置文件中使用标签引入外部属性文件

   <!-- 引入外部属性文件-->
   <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
   <!--配置连接池 -->
   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
     <property name="driverClassName" value="${prop.driverClass}"></property>
     ...
   </bean>
   

IOC操作Bean管理——注解方式

注解可以作用在类、属性、方法上面，可以简化我们的xml配置。

Spring针对Bean管理中创建对象提供的注解四种，他们都作用在类上面：

• @Component
• @Service
• @Controller
• @Repository

*** 这四个注解功能是一样的，都可以用来创建bean实例，只不过在开发中为了清晰的表明这个bean用在哪一个层上面**

使用注解创建对象

1. 引入AOP依赖

   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>5.2.8.RELEASE</version>
   </dependency>
   

2. 开启组件扫描

   指定要扫描的包，这个包中的类有注解就回去创建对象。

   首先引入context名称空间

       <!--开启组件扫描
           1 如果扫描多个包，多个包使用逗号隔开
           2 也可以扫描包的上层目录（推荐）
       -->
       <context:component-scan base-package="com.atguigu.spring5"></context:component-scan>
   

3. 创建类，在类上面添加创建对象注解即可

   //value属性可以省略不写，默认值是类名称首字母小写
   @Component(value = "userService") //<bean id="userService" class="..."></bean>
   public class UserService{
     //...
   }
   

开启组件扫描细节配置

这个表示只扫描包里面带Controller注解的类

<!--示例1
        use-default-filters="false" 表示现在不使用默认的filter（所有类都扫描），自己配置filter
        context:include-filter，设置扫描哪些内容
 -->
<context:component-scan base-package="com.atguigu.spring5" use-default-filters="false">
  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--示例2
        context:exclude-filters：设置哪些内容不进行扫描
    -->
<context:component-scan base-package="com.atguigu.spring5">
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

基于注解方式实现属性注入

• @AutoWired：根据属性类型进行自动装配(byType)，不需要添加set方法，如果接口有多个实现类的话，@AutoWired就不知道找哪个了，这个时候就要配合@Qualifier根据名称进行自动装配了

• @Qualifier：根据属性名称进行自动装配(byName)，要和@AutoWired一起使用

  @AutoWired
  @Qualifier(value = "userDaoImpl")
  private UserDao userDao;
  

• @Resource：可以根据类型注入，也可以根据名称注入。这个注解在javax.annotation.Resource包中，不是Spring本身提供的，因此官方建议使用前两者。

• @Value：注入普通类型属性

  @Value(value="abc")
  private String name;
  

完全注解开发

1. 创建配置类，替代xml配置文件

   @Configuration //Spring才能识别为配置类，替代xml文件
   @ComponentScan(basePackages = {"com.atguigu.spring5"})
   public class SpringConfig {
   
   }
   

2. 加载配置类

   ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
   

Spring AOP

概念

AOP：Aspect Oriented Programming，面向切面编程。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗点说就是：在不修改源代码的情况下增强类的功能。

底层原理

AOP底层使用动态代理。有两种情况动态代理：

• 有接口情况：使用JDK动态代理，创建接口实现类代理对象来增强接口功能
• 和没有接口情况：使用CGLIB动态代理，创建当前类子类的代理对象来增强类功能

使用JDK动态代理：

1. 使用java.lang.reflect.Proxy类里面的newProxyInstance方法创建代理对象，首先我们创建接口以及实现类

   static Object newProxyInstance(ClassLoader loader,class<?>[] interfaces,InvocationHandler h);
   //返回指定接口的代理类实现，该接口将方法调用分派给指定的调用处理程序
   //第一个参数：类加载器
   //第二个参数：增强类所实现的接口，可以有多个
   //第三个参数：实现InvocationHandler接口的一个对象，这个对象里面通过实现invoke()方法来写增强的逻辑
   

   public interface UserDao {
       public int add(int a,int b);
       public String update(String id);
   }
   
   //-------
   public class UserDaoImpl implements UserDao{
       public int add(int a, int b) {
           System.out.println("add方法执行了。。。");
           return a+b;
       }
   
       public String update(String id) {
           System.out.println("update方法执行了。。。");
           return id;
       }
   }
   

2. 使用Proxy类创建接口实现类代理对象

   public class JDKProxy {
       public static void main(String[] args) {
           //创建接口实现类代理对象
           Class[] interfaces = {UserDao.class};
   //        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
   //            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   //                return null;
   //            }
   //        });
           UserDaoImpl userDao = new UserDaoImpl();
           UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
           int result = dao.add(1,2);
           System.out.println("result："+result);
       }
   }
   
   class UserDaoProxy implements InvocationHandler{
       //1 创建的是谁的代理对象，就把谁传进来
       //有参构造传递
       private Object obj;
       public UserDaoProxy(Object obj){
           this.obj = obj;
       }
   
       //写增强逻辑
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           //方法之前
           System.out.println("方法之前执行。。。"+method.getName()+"传递的参数："+ Arrays.toString(args));
   
           //被增强的方法执行
           //这里也可以判断执行的方法去做不同的处理
           Object res = method.invoke(obj,args);
   
           //方法执行之后
           System.out.println("方法之后执行..."+obj);
           return null;
       }
   }
   

AOP术语

• 连接点：在一个类中，哪些方法可以被增强，这些方法称为连接点
• 切入点 ：实际被真正增强的方法
• 通知（增强）：实际增强的逻辑部分。通知有多种类型：前置通知、后置通知、环绕通知、异常通知、最终通知
• 切面：把通知应用到切入点的过程，指的是一个动作

Spring框架中一般都是基于AspectJ实现AOP操作，需要引入AOP相关依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--AspectJ 开始-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.0</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!--AspectJ 结束-->

AspectJ不是Spring的组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

AOP操作

切入点表达式作用：知道对哪个类里面的哪个方法进行增强

语法结构

execution([权限修饰符][返回类型][类全路径][方法名称][参数列表])

1. 对com.atguigu.dao.BookDao类里面的add方法进行增强

   execution(* com.atuguigu.dao.BookDao.add(..))
   

   *表示所有修饰符，返回类型可以省略

2. 对com.atguigu.dao.BookDao类里面的所有方法增强

   execution(* com.atuguigu.dao.BookDao.*(..))
   

3. 对com.atguigu.dao包里面所有类，类里面的所有方法进行增强

   execution(* com.atuguigu.dao.*.*(..))
   

AspectJ注解

1. 创建类，在类里面定义方法

   //被增强类
   @Component
   public class User {
       public void add(){
           System.out.println("add....");
       }
   }
   

2. 创建增强类（编写增强逻辑）

   在增强类里面创建方法，让不同的的方法代表不同的通知类型

   //增强类
   @Component
   @Aspect //生成代理对象
   public class UserProxy {
       //Before注解表示作为前置通知
       @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void before(){
           System.out.println("before....");
       }
   
       @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void after(){
           System.out.println("after...");
       }
   	 //方法返回后执行，比after早，有异常不执行
       @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void afterReturning(){
           System.out.println("afterReturning...");
       }
   	 //有异常执行
       @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void afterThrowing(){
           System.out.println("afterThrowing...");
       }
   
       //环绕通知：在方法之前和之后都通知
       @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
           System.out.println("环绕之前...");
   
           //被增强的方法执行
           proceedingJoinPoint.proceed();
   
           System.out.println("环绕之后...");
       }
   }
   

3. 进行通知配置

   在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"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                              http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
                              http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd">
   
       <!--引入context/aop名称空间-->
       <!--开启注解扫描-->
       <context:component-scan base-package="com.atguigu.spring5"></context:component-scan>
         <!--开启AspectJ生成代理对象-->
       <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
   
   </beans>
   

4. 配置不同类型的通知

   在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置。

5. 测试

       @Test
       public void testAopAnno(){
           ApplicationContext context = new FileSystemXmlApplicationContext("/src/main/java/bean1.xml");
           User user = context.getBean("user", User.class);
           user.add();
       }
   /*
   output:
   
   环绕之前...
   before....
   add....
   afterReturning...
   after...
   环绕之后...
   
   */
   

6. 相同的切入点抽取

       //相同切入点抽取
       @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
       public void pointdemo(){
   
       }
   
       //Before注解表示作为前置通知
       @Before(value = "pointdemo()")
       public void before(){
           System.out.println("before....");
       }
   

7. 有多个增强类对同一个方法进行增强，设置增强类的优先级。

   在增强类上面添加注解@Order(数字)，数字值越小优先级越高

AspectJ配置文件

AspectJ也可以通过配置文件使用

JdbcTemplate

概念

Spring框架对JDBC进行封装，使用JdbcTemplate可以很方便的实现对数据库的操作。

准备工作

1. 引入依赖

           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid</artifactId>
               <version>1.1.23</version>
           </dependency>
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.47</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-jdbc</artifactId>
               <version>5.2.10.RELEASE</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-tx</artifactId>
               <version>5.2.10.RELEASE</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-orm</artifactId>
               <version>5.2.6.RELEASE</version>
           </dependency>
   

2. 在spring配置文件配置数据库连接池

3. 配置JdbcTemplate对象，注入DataSource

       <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
           <!-- 注入dataSource -->
           <property name="dataSource" ref="dataSource"></property>
       </bean>
   

4. 创建dao类，注入jdbcTemplate对象；创建service类，注入dao对象

CRUD操作

1. 增删改操作使用的是update(String sql, Object... args)函数

   @Repository
   public class BookDaoImpl implements BookDao{
     //注入jdbcTemplate
     private JdbcTemplate jdbcTemplate;
   
     //添加方法
     @Override
     public void add(Book book){
       //1 创建sql语句
       String sql = "insert into t_book values(?,?,?)";
       //2 调用方法实现
       Object[] args = {book.getUserId(),book.getUsername(),book.getUstatus};
       int update = jdbcTemplate.update(sql,args);
     }
   }
   

2. 查询返回某一个值

   查询操作使用的是queryForObject(String sql, Class<T> requiredType)方法，第二个参数表示查询操作的返回类型。

   String sql = "select count(*) from t_book";
   Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
   

3. 查询返回对象

   queryForObject(String sql,RowMapper<T> rowMapper,Object... args)

   query(String sql,RowMapper<T> rowMapper,Object... args)：返回对象列表

   第二个参数rowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

   String sql = "select * from t_book where user_id=?";
   //调用方法
   Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
   

4. 批量操作

   batchUpdate(String sql,List<Object[]> batchArgs)

   public void batchAdd(List<Object[]> batchArgs){
     String sql = "insert into t_book values(?,?,?)";
     int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
   }
   

Spring声明式事务

Sping事务管理介绍

1. 事务添加到JavaEE三层结构里面Service层（业务逻辑层）

2. 在Spring进行事务管理操作有两种方式：编程式和声明式

   编程式

   public void accountMoney(){
     try{
       //1 开启事务
   
       //2 进行业务操作
       userDao.reduceMoney();
   
       userDao.addMoney();
       //3 没有发生异常，提交事务
     }catch(Exception e){
       //4 出现异常 事务回滚
     }
   }
   

3. 声明式事务管理有基于注解方式，也有基于xml配置文件方式

4. 在Spring进行声明式事务管理，底层使用AOP原理

5. Spring事务管理API提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解方式

1. 在配置文件中配置事务管理器，并开启事务注解

   <!-- 创建事务管理器 -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <!-- 注入数据源 -->
     <property name="dataSource" ref="dataSource"></property>
   </bean>
   
   <!-- 开启事务注解 引入名称空间tx-->
   <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
   

2. 在service类上面添加事务注解@Transactional

   这个注解可以添加到类上面，也可以添加上方法上面，如果添加上类上面表示这个类里面所有的方法都添加事务。

3. 这个注解里面可以配置事务相关的参数

   propagation：事务传播行为。多事务方法（对数据库表中的数据发生变化的操作）进行互相调用，这个过程中事务是如何进行管理的。Spring定义了7种传播行为

   

   

   isolation：事务的隔离级别，默认是可重复读

   

   timeout：超时时间。事务需要在一定时间内进行提交，如果不提交进行回滚。默认值-1（没有超时），单位秒

   readOnly：是否只读。默认false，true表示只能做查询操作

   rolllbackFor：回滚。设置出现哪些异常进行回滚

   noRollbackFor：不回滚。设置出现哪些异常不进行回滚

xml方式

1. 配置事务管理器
2. 配置通知
3. 配置切入点和切面

<!--配置通知-->
<tx:advice id="txadvice">
	<!--配置事务参数-->
  <tx:attributes>
  	<!--指定哪种规则的方法上面添加事务-->
    <tx:method name="accountMoney" propagation="REQUIRED"></tx:method>
  </tx:attributes>
</tx:advice>

<aop:config>
	<!-- 配置切入-->
  <aop:pointcut id="pt" expression="execution(* com.atguigu.spring5.service.UserService.*(..))"/>
  <!-- 配置切面-->
  <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

完全注解开发

1. 创建配置类替代xml配置文件

   @Configuration
   @ComponentScan(basePackages="com.atguigu")
   @EnableTransactionManagement //开启事务
   public class TxConfig{
     //创建数据库连接池
     @Bean
     public DruidDataSource getDruidDataSource(){
       DruidDataSource dataSource = new DruidDataSource();
       dataSource.SetDriverClassName("");
       dataSource.SetUrl("");
       dataSource.SetUsername("");
       dataSource.SetPassword("");
       return dataSource;
     }
   
     //创建JdbcTemplate对象
     @Bean
     public JdbcTemplate getJdbcTemplate(DataSource dataSource){
       //到ioc容器中根据类型找到dataSource
       JdbcTemplate jdbcTemplate = new JdbcTemplate();
       //注入dataSource
       jdbcTemplate.setDataSource(dataSource);
       return jdbcemplate;
     }
   
     //创建事务管理器
     @Bean
     public DataSourceTransactionManager getDataSourceTransationManager(DataSource dataSource){
       DataSourceTransactionManager transactionManager = new DataSourceTransationManager();
       transactionManager.setDataSource(dataSource);
       return transactionManager;
     }
   }
   

Spring5新功能

整个Spring5框架的代码基于Java8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除。

整合日志框架

Spring5自带类通用的日志封装，已经移除了Log4jConfigListener，官方建议使用Log4j2。

Nullable注解和函数式注册对象

@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空。

Spring5核心容器支持函数时风格GenericApplicationContext，通过lambda表达式注册对象

public void test(){
	//1 创建GenericApplicationContext对象
  GenericApplicationConntext context = new GenericApplicationContext();
  //2 调用context的方法对象注册
  context.refresh();
  context.registerBean(User.class, ()-> new User());
  //context.registerBean("user1",User.class,()->new User());
  //3 获取在spring注册的对象
  User user = context.getBean("com.atguigu.spring5.test.User");
  //User user = context.getBean("user1");
}

支持整合JUnit5

SpringWebFlux

简介

WebFlux是Spring5添加新的模块，用于web开发，功能和SpringMVC类似，WebFlux使用当前一种比较流行的响应式出现的框架。

传统的web框架比如SpringMVC，这些基于Servlet容器，WebFlux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现。

同步异步针对调用者：调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步

阻塞和非阻塞针对被调用者：被调用者收到请求之后，做完请求任务之后才给出反馈就是阻塞，收到请求之后马上给出反馈然后再去做其他事情就是非阻塞

WebFlux特点：

• 非阻塞：在有限资源下，提高系统的吞吐量和伸缩性，以Reactor为基础实现响应式编程
• 函数式编程：Spring5框架基于java8，WebFlux使用java8函数式编程方式实现路由请求

WebFlux VS SpringMVC

• 都可以使用注解方式，都运行在Tomcat等容器中
• SpringMVC采用命令式编程，WebFlux采用异步响应式编程

响应式编程

响应式编程是一种面向数据流和变化传播的编程范式，这意味着可以在编程语言中很方便的表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

响应式编程使用观察者模式，在java8及之前的版本提供的观察者模式两个类Observer和Observerable。

在java8之后被Flow类取代

Reactor实现

响应式编程操作中，Reactor是满足Reactive规范框架，其有两个核心类Mono和Flux，这两个类实现接口Publisher，提供丰富操作符。Flux对象实现发布者，返回N个元素；Mono实现发布者返回0或1个元素。

Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：元素值、错误信号、完成信号。后两个代表终止信号，用于告诉订阅者数据流结束了，错误信号在终止数据流的同时把错误信息传递给订阅者。

1. 引入依赖

   <dependency>
     <groupId>io.projectreactor</groupId>
     <artifactId>reactor-core</artifactId>
     <version>3.3.5.RELEASE</version>
   </dependency>
   

2. public static void main(String[] args) {
     //just方法直接声明
     Flux.just(1,2,3,4);
     Mono.just(1);
   
     //其他方法
     Integer[] array = {1,2,3,4};
     Flux.fromArray(array);
   
     List<Integer> list = Arrays.asList(array);
     Flux.fromIterable(list);
   
   }
   

3. 错误信号和完成信号都是终止，不能共存；如果没有发送任何元素值，而是直接发送错误或完成信号表示空数据流；如果没有错误信号，没有完成信号，表示无限数据流。

4. 调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流。

5. 对数据流进行一道道操作，成为操作符，比如工厂流水线

   map：元素映射为新元素

   

   flatMap：把每个元素转换成流，把转换之后的多个流合并成大的流

   

WebFlux执行流程和核心API

WebFlux基于Reactor，默认容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架。

SpringWebFlux执行过程和SpringMVC相似：

• SpringWebFlux核心控制器DispatchHandler，负责请求的处理，实现WebHandler接口
• HandlerMapping：请求查询到处理的方法
• HandlerAdapter：真正负责请求处理
• HandlerResultHandler：响应结果处理

SpringWebFlux实现函数式编程的两个接口：RouterFunction（路由处理）和HandlerFunction（处理函数）

基于注解编程模型

使用注解编程模型方式，和之前SpringMVC使用相似，只需要把相关依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器。

1. 引入webflux相关依赖，创建一个SpringBoot工程

           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-webflux</artifactId>
               <version>2.3.5.RELEASE</version>
           </dependency>
   

2. 创建实体类User，以及service类

   @Service
   public class UserServiceImpl implements UserService {
   
       //创建map集合存储数据
       private final Map<Integer,User> users = new HashMap<Integer, User>();
   
       public UserServiceImpl(){
           this.users.put(1,new User("lucy","boy",20));
           this.users.put(2,new User("mary","girl",20));
           this.users.put(3,new User("jack","boy",20));
       }
   
       public Mono<User> getUserById(int id) {
           return Mono.justOrEmpty(this.users.get(id));
       }
   
       public Flux<User> getAllUser() {
           return Flux.fromIterable(this.users.values());
       }
   
       public Mono<Void> saveUserInfo(Mono<User> userMono) {
           return userMono.doOnNext(person ->{
               //向map集合里面放值
               int id = users.size();
               users.put(id,person);
           }).thenEmpty(Mono.empty());//Mone.empty()表示数据流结束
       }
   }
   

3. 创建controller

   @RestController
   public class UserController {
       @Autowired
       private UserService userService;
   
       @GetMapping("/user/{id}")
       public Mono<User> getUserById(@PathVariable int id){
           return userService.getUserById(id);
       }
   
       @GetMapping("/user")
       public Flux<User> getUsers(){
           return userService.getAllUser();
       }
   
       @PostMapping("/saveuser")
       public Mono<Void> saveUser(@RequestBody User user){
           Mono<User> userMono = Mono.just(user);
           return userService.saveUserInfo(userMono);
       }
   }
   

虽然形式上和SpringMVC方式差不多，但是底层不一样了。前者基于SpringMVC+Servelet+Tomcat，后者基于SpringWebFlux+Reactor+Netty。

基于函数式编程模型

在使用函数式编程模型操作时，需要自己初始化服务器。

基于函数式编程模型的时候，有两个核心接口：RouterFunction（实现路由功能，请求转发给对应的Handler）和HandlerFunction（处理请求生成响应的函数）。核心任务定义两个函数式接口的实现并且启动需要的服务器。

SpringWebFlux请求和响应不再是ServletRequest和ServeltResponse，而是ServerRequest和ServerRespone。

1. 创建Handler

   public class UserHandler {
   
       private final UserService userService;
       public UserHandler(UserService userService){
           this.userService = userService;
       }
   
       public Mono<ServerResponse> getUserById(ServerRequest serverRequest){
           int userID = Integer.valueOf(serverRequest.pathVariable("id"));
           //空值处理
           Mono<ServerResponse> notFount = ServerResponse.notFound().build();
           Mono<User> userMono = this.userService.getUserById(userID);
           //把userMono进行转换返回
           //使用Reactor操作符flatMap
           return userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                   .body(fromObject(person)))
                   .switchIfEmpty(notFount);
       }
   
       public Mono<ServerResponse> getAllUsers(ServerRequest serverRequest){
           //调用service得到结果
           Flux<User> users = this.userService.getAllUser();
           return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
       }
   
       public Mono<ServerResponse> saveUser(ServerRequest serverRequest){
           //得到user对象
           Mono<User> userMono = serverRequest.bodyToMono(User.class);
           return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
       }
   }
   

2. 初始化服务器，编写Router和adapter

   

   public class Server {
       public static void main(String[] args) throws Exception {
           Server server = new Server();
           server.createReactorService();
           System.out.println("enter to exit");
           System.in.read();
       }
   
       //1 创建Router路由
       public RouterFunction<ServerResponse> routingFunction(){
           UserService userService = new UserServiceImpl();
           UserHandler userHandler = new UserHandler(userService);
   
           return RouterFunctions.route(
                   GET("/users/{id}").and(accept(MediaType.APPLICATION_JSON)),userHandler::getUserById
           ).andRoute(
                   GET("/users").and(accept(MediaType.APPLICATION_JSON)),userHandler::getAllUsers
           );
   
       }
   
       // 2 创建服务器完成适配
       public void createReactorService(){
           //路由和Handler适配
           RouterFunction<ServerResponse> route = routingFunction();
           HttpHandler httpHandler = toHttpHandler(route);
           ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
   
           //创建服务器
           HttpServer httpServer = HttpServer.create();
           httpServer.handle(adapter).bindNow();
       }
   }