Spring5

最新推荐文章于 2022-06-21 14:26:36 发布

Setsail0918

最新推荐文章于 2022-06-21 14:26:36 发布

阅读量318

点赞数

本文链接：https://blog.csdn.net/weixin_45804541/article/details/122713246

版权

Spring5

1、spring是什么？

Spring是轻量级的开源的JavaEE框架，解决了企业应用开发的复杂性，两个核心部分：IOC和AOP，但还有其他如事务、MVC等功能。

Spring为简化企业级应用开发而生，使用Spring可以使简单的JavaBean实现以前只有EJB才能实现的功能。

Spring是一个IOC(DI)和AOP容器框架。

Spring框架主要由七部份组成

分别是Spring Core、Spring AOP、Spring ORM、Spring DAO、Spring Context、Spring Web、Spring Web MVC

（1）IOC：控制反转，把创建对象过程交给Spring进行管理

（2）AOP：面向切面，在不修改源代码的情况下进行功能的增加或功能的增强

2、Spring容器是什么？

从概念上讲：Spring 容器是 Spring 框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。

从具象化讲：在java项目中，我们使用实现了org.springframework.context.ApplicationContext接口的实现类。在web项目中，我们使用spring.xml——Spring的配置文件。

从代码上讲：一个Spring容器就是某个实现了ApplicationContext接口的类的实例。也就是说，从代码层面，Spring容器其实就是一个ApplicationContext（一个实例化对象）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o5lhFgLv-1643250160093)(D:/Typora/image/IMG_0369.PNG)]

Spring容器类别及特点

##3、Spring框架图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qxQZ90XF-1643250160095)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0380.JPG)]

4、Spring特点

方便解耦，简化开发
AOP编程支持
方便程序测试
方便和其他框架进行整合
方便进行事务操作
降低JavaEE API难度

轻量级：Spring是非侵入性的-基于Spring 开发的应用中的对象可以不依赖于Spring的API。

依赖注入(DI、IOC)

面向切面编程（AOP）

容器：Spring是一个容器，因为它包含着并且管理应用对象的生命周期。

框架：Spring实现了使用简单的组件配置组合成一个复杂的应用，在Spring中可以使用XML和java注解组合这些对象。

一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring自身也提供了展现层的 SpringMVC和持久层的 Spring JDBC）。

5、Spring5-idea

1.导入jar包

commons-logging-1.2.jar
spring-beans-5.2.6.RELEASE.jar
spring-context-5.2.6.RELEASE.jar
spring-core-5.2.6.RELEASE.jar
spring-expression-5.2.6.RELEASE.jar

2.创建普通类

3.创建Spring配置文件，在配置文件中配置创建的对象

（1）Spring配置文件使用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">
    <!-- 配置User对象创建-->
    <bean id="user" class="com.kp.spring5.User></bean>

</beans>

4.进行测试代码编写

public class TestSpring5 {

    @Test
    public void testAdd(){
        //1.加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        User user=context.getBean("user",User.class);

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

6、IOC容器

（1）IOC底层原理

1.什么是IOC ？

（1）Inversion of Control 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

（2）使用IOC目的：为了降低耦合度

（3）入门案例就是IOC实现

2.IOC底层原理

（1）XML解析、工厂模式（目的是为了解耦合）、反射

（2）IOC过程：第一步 xml配置文件，配置创建的对象

第二步有service类和dao类，创建工厂类

class UserFactory{
public static UserDao getDao(){

String classValue=class属性值;

Class clazz=Class.forName(classValue);

return (UserDao)clazz.newInstance();

}

（2）IOC接口（BeanFactory）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
Spring提供IOC容器实现方式：（两个接口）

（1）BeanFactory：IOC容器基本实现，是Spring内部使用接口，不提供开发人员使用

*加载配置文件的时候不会创建对象，在获取（使用）对象的时候才去创建对象

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

*加载配置文件时就会把在配置文件对象进行创建
1. ApplicationContext接口有实现类
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-94wpQt1N-1643250160095)(D:/Typora/image/Snipaste_2022-01-09_18-59-51.png)]
  
  FileSystemXmlApplicationContext:盘路径，全路径
  
  ClassPathXmlApplicationContext:类路径，即src下类路径

（3）IOC操作 Bean管理（什么是Bean管理）

什么是Bean管理
Bean 管理指的是两个操作：

（1）Spring创建对象

（2）Spring注入属性

而Bean 管理操作有两种方式：

##7、IOC 操作 Bean管理（基于XML配置文件方式）

###（1）基于xml方式创建对象

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

（1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

（2）在bean标签中有很多属性，介绍常见的属性

id属性：获取的对象的唯一标识

class属性：类全路径（包类路径）

name属性：早期特殊属性，与id属性相似，与id不同的它是可以用特殊符号

（3）创建对象的时候，默认也是执行无参数构造方法

###（2）基于xml方式注入属性

（1）DI：依赖注入，就是注入属性，是IOC的一种具体实现，在创建对象的基础上完成。

第一种注入方式：使用set方法进行注入

（1）创建类，定义属性和对应的set方法

public class Book {
    //创建属性
    private String bname;
    private String bauthor;
    //创建属性对应的set方法
    public void setBname(String bname){
        this.bname=bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

（2）在spring配置文件中配置对象创建，配置属性注入

<!--2 set方法注入属性  -->
   <bean id="book" class="com.kp.spring5.testdemo.Book">
       <!--使用property完成属性注入
           name:类里面属性名称
           value:向属性注入的值
       -->
       <property name="bname" value="雪中悍刀行"></property>
       <property name="bauthor" value="纵横天下"></property>
   </bean>

第二种注入方式：使用有参数构造注入

（1）创建类，定义属性，创造属性对应有参数构造方法

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname,String address){
        this.oname=oname;
        this.address=address;
    }

（2）在spring配置文件中进行配置

<!--3 有参数构造注入属性-->
    <bean id="orders" class="com.kp.spring5.testdemo.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
        <!--也可以用<constructor-arg index="0" value="China"></constructor-arg> 0代表第一个属性名-->
    </bean>

p名称空间注入（了解即可）

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

第一步添加p名称空间在配置文件中
```
 xmlns:p="http://www.springframework.org/schema/p"
```
第二步进行属性注入，在bean标签里面进行操作
```
<bean id="book" class="com.kp.spring5.testdemo.Orders" p:bname="雪中悍刀行" p:bauthor="烽火戏诸侯">
</bean>
```

public class Book{
  private String bname;
  //set方法注入
  public void setBname(String bname){
    this.bname=bname;
  }
  
  //有参数构造注入
  public Book(String bname){
    this.bname=bname;
  }
  public static void main(String[] args){
	Book book=new Book("abc");
  }
}

###（3）基于xml的注入其他类型属性

####1.字面量（固定值）

（1）null值

<!--向属性里面设置null值-->
<property name="address">
    <null/>
</property>

（2）属性值包含特殊符号

<!--属性值中含特殊符号
    1.把<>进行转义&lt;&gt
    2.把带特殊符号的内容写到CDATA
-->
<property name="address">
    <value><![CDATA[<<>>武汉]]></value>
</property>

####2.注入属性-外部bean

#####首先，明白MVC的dao层、service层和controller层

dao层主要做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，dao层的设计首先是设dao层的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可以再模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，dao层的数据源配置，以及有关数据库连接参数都在Spring配置文件中进行配置。

service层主要负责业务模块的应用逻辑应用设计。同样是首先设计接口，再设计其实现类，接着在Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用service接口来进行业务处理。service层的业务实，具体要调用已经定义的dao层接口，封装service层业务逻辑有利于通用的业务逻辑的独立性和重复利用性。程序显得非常简洁。

controller层负责具体的业务模块流程的控制，在此层要调用service层的接口来控制业务流程，控制的配置也同样是在Spring的配置文件里进行，针对具体的业务流程，会有不同的控制器。我们具体的设计过程可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块。这样不仅使程序结构变得清晰，也大大减少了代码量。

实现方法：

（1）创建两个类service类和dao类

public class UserService {

    //创建UserDao类型属性，生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("Service add......");
        userDao.update();
        //原始方法：创建UserDao对象,然后调用方法
        //UserDao userdao=new UserDaoImpl();
        //userdao.update();
    }

}

    //实现类：实现UserDao的Interface接口
public class UserDaoImpl implements UserDao{

        @Override
        public void update() {
            System.out.println("dao update...");
        }
    }

（2）在service调用dao里面的方法

（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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                          http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--1 service和dao对象创建-->
   <bean id="userService" class="com.kp.spring5.service.UserService">
      <!--注入userDao对象
         name属性值：类里面的属性名称
         ref属性：创建的userDao对象bean标签的id值
      -->
      <property name="userDao" ref="userDaoImpl"></property>
   </bean>

   <bean id="userDaoImpl" class="com.kp.spring5.dao.UserDaoImpl"></bean><!--接口不能直接new对象，要找它的实现类-->

</beans>

（4）测试结果

public class TestBean {

    @Test
    public void testAdd(){
        //1 加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");

        //2 获取配置创建的对象
        UserService userService=context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

####3.注入属性-内部bean和级联赋值

（1）一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

//部门类
public class Department {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

//员工类
public class Employees {
    private String ename;
    private String gender;
//生成set方法注入属性
    //员工属于哪个部门，使用对象形式表示
    private Department department;
    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

（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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                          http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--内部bean-->
    <!--<bean id="department" class="com.kp.spring5.bean.Department">
        <property name="dname" value=""></property>
    </bean>不在外部设置属性了-->
    <bean id="employees" class="com.kp.spring5.bean.Employees">
        <!--设置两个普通属性-->
        <property name="ename" value="张三"></property>
        <property name="gender" value="男"></property>
        <!--设置对象类型属性-->
        <property name="department">
            <bean id="department" class="com.kp.spring5.bean.Department">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>

</beans>

####4.注入属性-级联赋值

（1）第一种写法

 <!--级联赋值-->
<bean id="employees" class="com.kp.spring5.bean.Employees">
   <!--设置两个普通属性-->
   <property name="ename" value="张三"></property>
   <property name="gender" value="男"></property>
   <!--级联赋值-->
   <property name="department" ref="department">

   </property>
</bean>
<bean id="department" class="com.kp.spring5.bean.Department">
   <property name="dname" value="财务部"></property>
</bean>

（2）第二种写法

首先必须要先生成对象的get方法

//员工属于哪个部门，使用对象形式表示
private Department department;
//生成department的get方法，为了使用级联赋值的第二种方法

public Department getDepartment() {
    return department;
}

   <!--级联赋值-->
   <bean id="employees" class="com.kp.spring5.bean.Employees">
      <!--设置两个普通属性-->
      <property name="ename" value="张三"></property>
      <property name="gender" value="男"></property>
      <!--级联赋值-->
      <property name="department" ref="department"></property>
      <property name="department.dname" value="技术部"></property>
   </bean>
   <bean id="department" class="com.kp.spring5.bean.Department">
      <property name="dname" value="财务部"></property>
   </bean>
</beans>

输出结果是员工：张三，性别：男，部门：Department{dname=‘技术部’}

5.基于xml注入集合属性

注入数组类型属性、List集合类型属性、Map集合类型属性、Set集合类型属性

（1）创建类，定义数组、list、map、set类型属性

public class Stu {
    //1 数组类型的属性
    private String[] courses;

    //2 List集合类型属性
    private List<String> list;

    //3 Map集合类型属性
    private Map<String,String> maps;

    //4 set集合类型属性
    private Set<String> sets;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
}

（2）在Spring配置文件中进行配置

<!--1 集合类型属性的注入-->
<bean id="stu" class="com.kp.Spring5.collectiontype.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="maps">
      <map>
         <entry key="JAVA" value="java"></entry>
         <entry key="PHP" value="php"></entry>
      </map>
   </property>
   <property name="sets">
      <set>
         <value>MySQL</value>
         <value>Redis</value>
      </set>
   </property>
</bean>

2.在集合里面设置对象类型值

//课程类
public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }
}

//学生所学多门课程
private List<Course> courseList;
 public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

<!--注入list集合类型，值是对象类型-->
   <property name="courseList">
      <list>
         <ref bean="course1"></ref>
         <ref bean="course2"></ref>
      </list>
   </property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="com.kp.Spring5.collectiontype.Course">
   <property name="cname" value="Spring5框架课程"></property>
</bean>
<bean id="course2" class="com.kp.Spring5.collectiontype.Course">
   <property name="cname" value="MyBatis框架课程"></property>
</bean>

3.把集合注入部分提取出来做成公共部分

（1）在spring配置文件中引入名称空间 util

<?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: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/util/spring-util.xsd">
</beans>

（2）使用util标签完成list集合注入提取

<!--1 提取list集合类型属性注入-->
<util:list id="boolList">
   <!--<ref bean=""></ref>若属性的值是对象类型，则写ref并创建多个对象-->
   <value>雪中悍刀行</value>
   <value>斗罗大陆</value>
   <value>武动乾坤</value>
   <value>活着</value>
</util:list>
<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.kp.Spring5.collectiontype.Book">
   <property name="list" ref="bookList"></property>
</bean>

（4）IOC 操作 Bean 管理（FactoryBean）

Spring有两种类型的bean，一种普通bean，另外一种工厂bean（FactoryBean）
普通bean：在spring配置文件中定义bean是什么类型就返回什么类型

工厂bean：在配置文件中定义bean类型可以和返回类型不一样

（1）第一步创建类，让这个类作为工厂bean，实现接口FactoryBean

（2）第二步实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {

    //定义返回bean类型
    @Override
    public Course getObject() throws Exception {
        Course course=new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

配置文件：

<bean id="myBean" class="com.kp.Spring5.collectiontype.factorybean.MyBean"></bean>

测试类：

@Test
public void testCollection3(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
    Course course=context.getBean("myBean", Course.class);
    System.out.println(course);
}

（5）IOC 操作 Bean 管理（bean 作用域）

在Spring里面，我们可以设置创建bean实例是单实例还是多实例
在Spring里面，默认情况下，bean是一个单实例对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aOw2rkzv-1643250160096)(D:/Typora/image/Snipaste_2022-01-10_19-29-06.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-otIisx8Y-1643250160096)(D:/Typora/image/Snipaste_2022-01-10_19-29-26.png)]

把对象获取多次然后输出，输出之后比较其地址，若地址相同则说明是单实例对象。

如何设置单实例还是多实例

（1）在spring配置文件bean标签里面有属性==(scope)==用于设置是单实例还是多实例

（2）scope属性值

第一个值默认值：singleton ，表示是单实例对象

第二个值 prototype ，表示是多实例对象
```
<bean id="book" class="com.kp.Spring5.collectiontype.Book" scope="prototype">
   <property name="list" ref="bookList"></property>
</bean>
```
（3）singleton 和 prototype 的区别

第一： singleton表示单实例，prototype表示多实例。

第二：设置 scope 值是 singleton 时，加载spring配置文件时就会创建单实例对象。

设置 scope 值是prototype时，不是在加载spring配置文件的时候创建对象，而是在调用getBean方法的时候创建多实例对象。

request、session了解

（6）IOC 操作 Bean 管理（bean 生命周期）

生命周期

（1）从对象创建到对象销毁的过程
bean生命周期

（1）通过构造器创建bean实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 的引用（调用 set 方法）

（3）调用 bean 的初始化的方法（需要进行配置）

（4）bean可以使用了（对象获取到了）

（5）当容器关闭的时候，调用bean的销毁的方法

演示bean生命周期

（1）创建类

public class Orders {

    //无参数构造
    public Orders(){
        System.out.println("第一步 执行无参数构造创建bean实例");
    }
    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行时的初始化方法
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }
}

（2）测试类

@Test
public void testBean4(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders=context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);

    //手动让bean实例销毁
    ((ClassPathXmlApplicationContext) context).close();
}

（3）Spring文件配置

<bean id="orders" class="com.kp.Spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
   <property name="oname" value="手机"></property>
</bean>

（4）测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RurdrhxC-1643250160097)(D:/Typora/image/Snipaste_2022-01-10_21-23-49.png)]

bean的后置处理器，bean生命周期有七步

（1）通过构造器创建bean实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 的引用（调用 set 方法）

（3）把bean实例传递bean后置处理器的方法

postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置）

（5）把bean实例传递bean后置处理器的方法

postProcessAfterInitialization

（6）bean可以使用了（对象获取到了）

（7）当容器关闭的时候，调用bean的销毁的方法

演示添加后置处理器效果

（1）创建类，实现接口BeanPostProcessor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

<!--配置后置处理器-->
<bean id="myBeanPost" class="com.kp.Spring5.bean.MyBeanPost"></bean>

效果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qgZArQL7-1643250160097)(D:/Typora/image/Snipaste_2022-01-11_11-16-54.png)]

（7）IOC 操作 Bean 管理（xml 自动装配）

1.什么是自动装配

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

2.演示自动装配过程

（1）根据属性名称自动注入

<!--实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName根据属性名称注入，注入值bean的id值和类属性名称一样
        byType根据属性类型注入
-->
<bean id="employee" class="com.kp.Spring5.autowire.Employee" autowire="byName">
   <!-- <property name="department" ref="department"></property>-->
    <!-- collaborators and configuration for this bean go here -->
</bean>

<bean id="department" class="com.kp.Spring5.autowire.Department">
    <!-- collaborators and configuration for this bean go here -->
</bean>

（2）根据属性类型自动注入

<!--实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName根据属性名称注入，注入值bean的id值和类属性名称一样
        byType根据属性类型注入
-->
<bean id="employee" class="com.kp.Spring5.autowire.Employee" autowire="byType">
   <!-- <property name="department" ref="department"></property>-->
    <!-- collaborators and configuration for this bean go here -->
</bean>

<bean id="department" class="com.kp.Spring5.autowire.Department">
    <!-- collaborators and configuration for this bean go here -->
</bean>

###（8）IOC 操作 Bean 管理（外部属性文件）

直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖jar包

druid-1.1.9.jar

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property><!--代表驱动名称-->
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property><!--代表数据库地址-->
    <property name="username" value="root"></property><!--连接数据库的用户名-->
    <property name="password" value="root"></property><!--连接数据库的密码-->

引入外部属性文件配置数据库连接池

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yg07JEgQ-1643250160098)(D:/Typora/image/Snipaste_2022-01-11_13-29-39.png)]

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

* 引入context名称空间

<?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"
       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">

* 在spring配置文件中使用标签引入外部属性文件

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClass}"></property><!--代表驱动名称-->
    <property name="url" value="${prop.url}"></property><!--代表数据库地址-->
    <property name="username" value="${prop.username}"></property><!--连接数据库的用户名-->
    <property name="password" value="${prop.password}"></property><!--连接数据库的密码-->

</bean>

8、IOC 操作 Bean 管理（基于注解方式）

1、什么是注解

（1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）

（2）使用注解可以作用在类上面，方法上面，属性上面

（3）使用注解目的：为了简化xml配置

2、Spring里面针对Bean管理中创建对象提供注解

（1）@Component

（2）@Service 一般用在业务逻辑层或service层上

（3）@Controller 一般用在web层上

（4）@Repository 一般用在Dao 层或持久层上

上面四个注解的功能是一样的，都可以用来创建bean实例

###（1）基于注解方式实现对象创建

（1）第一步引入依赖

spring-aop-5.2.6.RELEASE.jar

（2）第二步开启组件扫描

<!--开启组件扫描
    1 如果扫描多个包，多个包之间使用逗号隔开
    2 写扫描包上层目录
-->
<context:component-scan base-package="com_kp_Spring5"></context:component-scan>

（3）第三步创建类，在类上面添加创建对象注解（四个注解都可行）

//在注解里面value属性可以省略不写
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService")//<bean id="userService" class="包内路径"></bean>等同
public class UserService {

    public void add(){
        System.out.println("add service.......");
    }
}

4.开启组件扫描细节配置

<!--示例1
    use-default-filters="false" 表示现在不使用默认filter，自己配置filter
    context：include-filter，设置扫描哪些内容
-->

<context:component-scan base-package="com_kp_Spring5" use-default-filters="false"><!--表示不扫描所有内容-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    <!--表示只扫描带注解为Component的类-->
</context:component-scan>

<!--示例2
    下面配置扫描包里面的所有内容
    context:exclude-filter ：设置哪些内容不进行扫描
-->

<context:component-scan base-package="com_kp_Spring5">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
</context:component-scan>

（2）基于注解方式实现属性注入

（1）@AutoWired（常用）

根据属性类型进行自动装配

第一步把service和dao对象创建，在service和dao类添加创建对象注解

第二步在service里注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Component(value = "userService")//<bean id="userService" class="包内路径"></bean>等同
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("add service.......");
        userDao.add();
    }
}

（2）@Qualifier

根据属性名称进行注入

这个注解的使用要和上面@AutoWired一起使用

@Component(value = "userService")//<bean id="userService" class="包内路径"></bean>等同
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired //根据类型进行注入
    @Qualifier(value = "userDaoImpl1") //一个接口可能有多个实现类，根据名称进行注入特定类型属性
    private UserDao userDao;

    public void add(){
        System.out.println("add service.......");
        userDao.add();
    }
}

（3）@Resource

可以根据类型注入，也可以根据名称注入

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

public void add(){
    System.out.println("add service.......");
    userDao.add();
}

（4）@value

注入普通类型属性

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

（3）纯注解开发

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

@Configuration //作为配置类，替代xml替代文件
@ComponentScan(basePackages = {"com_kp_Spring5"})
public class SpringConfig {
    
}

（2）编写测试类

@Test
//纯注解开发
//加载配置类
public void TestUserService2(){
    ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService=context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}

##9、AOP

（1）什么是AOP ？Aspect Oriented Programming

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

2、通俗描述：可以不通过修改源代码的方式，在主干功能里添加新的功能。

3、使用登录例子来说明AOP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BMWaiyei-1643250160098)(file:///D:/%E4%B8%8B%E8%BD%BD/1156577092/FileRecv/MobileFile/IMG_0371.JPG?lastModify=1641907301)]

（2）AOP 底层原理

1、AOP底层使用动态代理

（1）有两种情况的动态代理

第一种 有接口的情况，使用JDK动态代理

创建接口实现类代理对象，增强类的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XGqdp0Ij-1643250160098)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0372.JPG)]

第二种 没有接口的情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gxv3OTFA-1643250160099)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0373.JPG)]

（3）AOP（JDK动态代理）

1、使用JDK动态代理，使用Proxy类里面的方法创建代理对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-suy6YH5Y-1643250160099)(D:/Typora/image/Snipaste_2022-01-12_11-13-20.png)]

（1）调用newProxyInstance [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eekkRdx1-1643250160099)(D:/Typora/image/Snipaste_2022-01-12_11-15-22.png)]

方法有三个参数：

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的方法

2、JDK动态代理代码

（1）创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public void update(String id);
}

（2）创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

（3）使用Proxy类创建接口的代理对象

package com_AOP;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
       /* Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        })匿名内部类*/

        UserDao 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){ //也可以用UserDaoImpl userDao传递
        this.obj=obj;
    }

    //invoke方法意味着：只要对象被创建，那么里面的方法就会被调用
    //增强的逻辑
    @Override
    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 res;
    }
}

（4）AOP 术语

####1、连接点

类里面哪些方法可以被增强，这些方法称为连接点。

####2、切入点

实际被真正增强的方法，称为切入点。

####3、通知（增强）

（1）实际增强的逻辑部分称为通知（增强）

（通知有多种类型）

####前置通知

####后置通知

####环绕通知

####异常通知

####最终通知

####4、切面

是动作

（1）把通知应用到切入点的过程

（5）AOP 操作（准备）

1、Spring 框架一般基于 AspectJ 实现 AOP 操作

（1）什么是 AspectJ

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

2、基于 AspectJ 实现 AOP 操作

（1）基于xml配置文件实现

（2）基于注解的方式实现（通常使用）

3、在项目工程里面引入 AOP 相关依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jauVV7Zc-1643250160100)(D:/Typora/image/Snipaste_2022-01-17_13-28-20.png)]

4、切入点表达式

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

（2）语法结构

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

举例 1：对 com.atguigu.dao.BookDao类里面的add进行增强

execution(public void com.atguigu.dao.BookDao.add(…))

execution(* com.atguigu.dao.BookDao.add(…))

举例 2：对com.atguigu.dao.BookDao类里面的所有方法进行增强

execution(* com.atguigu.dao.BookDao.*(…))

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

execution(* com.atguigu.dao.*.*(…))

（6）AOP 操作（AspectJ注解）

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

package com_AOP.aop;

public class User {
    public void add(){
        System.out.println("add...");
    }
}

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

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

package com_AOP.aop;

//增强类
public class UserProxy {

    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

3、进行通知的配置

（1）在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:component-scan base-package="com_AOP.aop"></context:component-scan>
</beans>

（2）使用注解创建User和UserProxy

import org.springframework.stereotype.Component;

//增强类
@Component
public class UserProxy {

    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

（3）在增强类上面添加注解 @Aspect

//增强类
@Component
@Aspect  //生成代理对象
public class UserProxy {

    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

（4）在Spring配置文件中开启生成代理对象

<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4、配置不同类型的通知（怎么做？）

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

//增强类
@Component
@Aspect  //生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示
    @Before(value="execution(* com_AOP.aop.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
}

package com_AOP.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect  //生成代理对象
public class UserProxy {

    //前置通知
    //@Before注解表示
    @Before(value="execution(* com_AOP.aop.User.add(..))")
    public void before(){
        System.out.println("before...");
    }

    //最终通知
    @After(value="execution(* com_AOP.aop.User.add(..))")
    public void after(){
        System.out.println("after...");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");//返回结果后通知
    }

    //异常通知
    @AfterThrowing(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }

    //环绕通知
    @Around(value = "execution(* com_AOP.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }
}

5、相同的切入点抽取

//相同切入点抽取
@Pointcut(value = "execution(* com_AOP.aop.User.add(..))") //切入点注解
public void pointdemo(){
    
}

//前置通知
//@Before注解表示
@Before(value="pointdemo()")
public void before(){
    System.out.println("before...");
}

6、有多个增强类多个同一方法进行增强，设置增强类优先级

（1）在增强类上面添加注解@Order（数字类型值），数字类型的值越小优先级越高

package com_AOP.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class PersonProxy {

    //后置通知(返回通知)
    @Before(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("Person Before.......");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y8xP0m3k-1643250160100)(D:/Typora/image/Snipaste_2022-01-18_17-03-07.png)]

（7）AOP 操作（AspectJ配置文件）

一般工作中还是用注解做到

1、创建两个类，增强类和被增强类，创建方法

package aop_xml;//被增强类

public class Book {
    public void buy(){
        System.out.println("buy...");
    }
}

package aop_xml;

import org.aspectj.lang.ProceedingJoinPoint;

public class BookProxy {

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

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

    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("around...");
        proceedingJoinPoint.proceed();
        System.out.println("around...");
    }
}

2、在 Spring 配置文件中创建两个类对象

<!--创建两个类的对象-->
<bean id="book" class="aop_xml.Book"></bean>
<bean id="bookProxy" class="aop_xml.BookProxy"></bean>

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: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/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--创建两个类的对象-->
    <bean id="book" class="aop_xml.Book"></bean>
    <bean id="bookProxy" class="aop_xml.BookProxy"></bean>

    <!--配置AOP增强类-->
    <aop:config>

        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* aop_xml.Book.buy(..))"/>

        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:around method="around" pointcut-ref="p"/>

        </aop:aspect>
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"/>

        </aop:aspect>
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:after method="after" pointcut-ref="p"/>

        </aop:aspect>

    </aop:config>
</beans>

4、完全使用注解开发

（1）创建配置类，不需要创建xml配置文件

package com_AOP.aop; //普通类

import org.springframework.stereotype.Component;

@Component
public class User {
    public void add(){
        //int i=10/0;
        System.out.println("add...");
    }
}

@Configuration //配置类
@ComponentScan(basePackages={"com_AOP"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAOP {
}

package com_AOP.aop; //优先增强类

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class PersonProxy {

    //后置通知(返回通知)
    @Before(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("Person Before.......");
    }
}

package com_AOP.aop; //增强类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect  //生成代理对象
@Order(3)
public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* com_AOP.aop.User.add(..))") //切入点注解
    public void pointdemo(){

    }

    //前置通知
    //@Before注解表示
    @Before(value="pointdemo()")
    public void before(){
        System.out.println("before...");
    }

    //最终通知
    @After(value="execution(* com_AOP.aop.User.add(..))")
    public void after(){
        System.out.println("after...");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");//返回结果后通知
    }

    //异常通知
    @AfterThrowing(value = "execution(* com_AOP.aop.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }

    //环绕通知
    @Around(value = "execution(* com_AOP.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }
}

    @Test //测试类
    public void testAopAnnotation(){
        ApplicationContext context=new AnnotationConfigApplicationContext(ConfigAOP.class);
        User user = context.getBean("user", User.class);
        user.add();
    }
}

10、JdbcTemplate（概念和准备工作）

1、什么是JdbcTemplate

（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库进行操作

2、准备工作

（1）引入相关jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h74OICdO-1643250160100)(D:/Typora/image/Snipaste_2022-01-19_15-37-33.png)]

（2）在Spring配置文件中配置数据库连接池

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

（3）配置JdbcTemplate对象，注入DataSource

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

（4）创建service类，创建dao类，在dao注入jdbcTemplate对象

配置文件中

<!-- 组件扫描 基于注解 -->
<context:component-scan base-package="com_kp"></context:component-scan>

Service文件中

@Service
public class BookService {

    //注入dao
    @Autowired
    private BookDao bookDao;

}

Dao文件中

@Repository
public class BookDaoImpl implements BookDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

JdbcTemplate 操作数据库（添加）

1、对应数据库创建实体类

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }

    public String getUserId() {
        return userId;
    }

    public String getUsername() {
        return username;
    }

    public String getUstatus() {
        return ustatus;
    }
}

2、编写 service 和 dao

（1）在dao进行数据库添加操作

（2）调用JdbcTemplate对象里面update方法实现添加操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LgHdoOQ6-1643250160101)(D:/Typora/image/Snipaste_2022-01-19_17-17-41.png)]

有两个参数
第一个参数：sql 语句
第二个参数：可变参数，设置 sql 语句值

package com_kp.dao;

import com_kp.entity.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao{

    //注入JdbcTemplate
    @Autowired
    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);
        System.out.println(update);
    }
}

3、测试类

package com_kp.test;

import com_kp.entity.Book;
import com_kp.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBook {

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService=context.getBean("bookService", BookService.class);

        Book book=new Book();
        book.setUserId("1");
        book.setUsername("java");
        book.setUstatus("a");
        bookService.addBook(book);
    }
}

11、JdbcTemplate 操作数据库（修改和删除）

    //修改
    @Override
    public void updateBook(Book book) {
        String sql="update t_book set username=?,ustatus=? where user_id=?";
        Object[] args={book.getUsername(),book.getUstatus(),book.getUserId()};
        int update=jdbcTemplate.update(sql,args);
        System.out.println(update);
    }

    //删除
    @Override
    public void delete(String id) {
        String sql="delete from t_book where user_id=?";
        int update=jdbcTemplate.update(sql,id);
        System.out.println(update);
    }

//测试类中
//修改
Book book=new Book();
book.setUserId("1");
book.setUsername("javaupup");
book.setUstatus("kp");
bookService.updateBook(book);

//删除
bookService.deleteBook("1");

12、JdbcTemplate 操作数据库（查询）

1、查询返回某个值

（1）查询表里面有多少条记录，返回是某个值

（2）使用JdbcTemplate实现查询返回某个值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kgg4nqXl-1643250160101)(D:/Typora/image/Snipaste_2022-01-20_10-16-29.png)]

有两个参数
第一个参数：sql语句
第二个参数：返回类型Class

//查询表中记录数 在实现类中
@Override
public int selectCount() {

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

//查询返回某个值 测试类中
int count = bookService.findCount();
System.out.println(count);

//查询表中记录数 service类
public int findCount(){
    return bookDao.selectCount();
}

2、查询返回对象

（1）场景：查询图书详情

（2）JdbcTemplate 实现查询返回对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tfAeJ4xv-1643250160101)(D:/Typora/image/Snipaste_2022-01-20_10-39-04.png)]

有三个参数
第一个参数：sql语句
第二个参数：RowMapper，是一个接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。
第三个参数：sql语句值

//查询返回对象 service类
public Book findone(String id){
    return bookDao.findBookInfo(id);
}

//查询返回对象 接口
Book findBookInfo(String id);

//接口实现类
@Override
public Book findBookInfo(String id) {
    String sql="select * from t_book where user_id=?";
    //调用方法
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
    return book;
}

//查询返回对象 测试类
Book book = bookService.findone("2");
System.out.println(book);

3、查询返回集合

（1）场景：查询图书列表分页…

（2）调用JdbcTemplate方法实现查询返回集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mDU2PF9Y-1643250160102)(D:/Typora/image/Snipaste_2022-01-20_13-57-18.png)]

第一个参数：sql语句
第二个参数：RowMapper，是一个接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。
第三个参数：sql语句值

@Override
public List<Book> findAllBook() {
    String sql="select * from t_book";
    //调用方法
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

//查询返回集合  测试类
List<Book> alllist = bookService.findAll();
System.out.println(alllist);

4、批量操作功能

（1）批量操作，操作表里的多条记录

（2）JdbcTemplate实现批量添加操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SOG3Fgsf-1643250160102)(D:/Typora/image/Snipaste_2022-01-20_18-25-02.png)]

有两个参数
第一个参数：sql语句
第二个参数：List集合，添加多条记录数据

//批量添加 service类
public void batchAdd(List<Object[]> batchArgs){
    bookDao.batchAddBook(batchArgs);
}

//批量添加 接口
void batchAddBook(List<Object[]> batchArgs);

//实现类
@Override 
public void batchAddBook(List<Object[]> batchArgs) {
    String sql="insert into t_book values(?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

//批量添加 测试类
List<Object[]> batchArgs=new ArrayList<>();
Object[] o1={"4","java","atguigu"};
Object[] o2={"1","python","atguigu"};
Object[] o3={"5","C++","atguigu"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

5、批量修改操作

//批量修改 service类
public void batchUpdate(List<Object[]> batchArgs){
    bookDao.batchUpdateBook(batchArgs);
}

//批量修改 接口
void batchUpdateBook(List<Object[]> batchArgs);

//批量修改 实现类
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
    String sql="update t_book set username=?,ustatus=? where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

//批量修改 测试类
List<Object[]> batchArgs=new ArrayList<>();
Object[] o1={"javaSpring","atguigu","4"};
Object[] o2={"python211","atguigu","1"};
Object[] o3={"C++985","atguigu","3"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);

6、批量删除操作

//批量删除 service类
public void batchDelete(List<Object[]> batchArgs){
    bookDao.batchDeleteBook(batchArgs);
}

//批量删除 接口
void batchDeleteBook(List<Object[]> batchArgs);

//批量删除 实现类
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
    String sql="delete from t_book where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));

}

//批量删除 测试类
List<Object[]> batchArgs=new ArrayList<>();
Object[] o1={"1"};
Object[] o2={"3"};
Object[] o3={"4"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量删除
bookService.batchDelete(batchArgs);

13、事务概念

（1）什么是事务？

1、事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有的操作都失败。

2、典型场景：银行转账

lucy转账100元给mary
lucy少100，mary多100

（2）事务四个特性（ACID）

1、原子性

2、一致性

3、隔离性

4、持久性

14、事务操作（搭建事务操作环境）

分析：银行转账环境有三层结构：Web层视图层、Service层业务逻辑层（业务操作）、Dao层数据访问层（写数据库操作方法，不写业务）

Dao层中创建两个方法（1）少钱的方法（2）多钱的方法

Service层创建转账的方法（1）调用dao两个的方法

1、添加数据库表，添加记录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tAHmPpb8-1643250160102)(D:/Typora/image/Snipaste_2022-01-21_12-24-58.png)]

2、创建service，搭建dao，完成对象创建和注入关系

（1）在service注入dao，在dao里面注入JdbcTemplate，在JdbcTemplate注入DataSource

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

}

@Repository
public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

3、在dao里面创建两个方法：少钱和多钱的方法，在service创建方法（转账的方法）

@Repository
public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //lucy转账100给mary
    //少钱方法
    @Override
    public void reduceMoney() {
        String sql="update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql,100,"lucy");

    }
    
    //多钱方法
    @Override
    public void addMoney() {
        String sql="update t_account set money=money+? where username=?";
        jdbcTemplate.update(sql,100,"mary");

    }
}

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    public void accountMoney(){
        //lucy少100
        userDao.reduceMoney();

        //mary多100
        userDao.addMoney();
    }

}

4、上面银行转账代码，如果正常执行是没有问题的，但是如果代码执行过程中出现异常，有问题

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    public void accountMoney(){
        //lucy少100
        userDao.reduceMoney();

        //模拟异常
        int i=10/0;

        //mary多100
        userDao.addMoney();
    }

}

（1）上面的问题如何解决呢？

使用事务进行解决

（2）事务操作过程

@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //转账的方法
    public void accountMoney(){
        try{
            //第一步 开启事务

            //第二步 进行业务操作

            //lucy少100
            userDao.reduceMoney();

            //模拟异常
            int i=10/0;

            //mary多100

            userDao.addMoney();
            //第三步 没有发生异常，提交事务
        }catch(Exception e){
            //第四步 出现异常，事务回滚
        }
    }

}

15、事务操作（Spring事务管理介绍）

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

2、在Spring进行事务管理操作

（1）有两种方式：编程式事务管理和声明式事务管理（使用）

3、声明式事务管理

（1）基于注解方式

（2）基于xml配置文件方式

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

5、在Spring事务管理API

（1）在Spring里面提供一个接口，提供事务管理器，这个接口针对不同的框架提供不同的实现类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2jIpTcc0-1643250160103)(D:/Typora/image/Snipaste_2022-01-21_20-48-45.png)]

16、事务操作（注解声明式事务管理）

（1）在Spring配置文件中配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource">

    </property>

</bean>

（2）在Spring配置文件，开启事务注解

1、在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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

2、开启事务注解

<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3、在service类上面（获取service类里面方法上面）添加事务注解

（1）@Transactional，这个注解添加到类上面，也可以添加方法上面

（2）如果把这个注解添加到类上面，这个类里面所有的方法都添加事务

（3）如果把这个注解添加到方法上面，为这个方法添加事务

@Service
@Transactional
public class UserService {

（3）事务操作（声明式事务管理参数配置）

1、在service类上面添加@Transactional，在这个注解里面可以配置事务相关参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H76UXNO6-1643250160103)(D:/Typora/image/Snipaste_2022-01-22_10-48-37.png)]

2、propagation：事务传播行为

（1）多事务方法直接进行调用，这个过程中事务是如何进行管理的

事务方法：对数据库表数据进行变化的操作（增删改）
有事务方法调无事务方法、无事务方法调有事务方法、有事务方法调有事务方法
Spring框架事务传播行为有7种

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U8L5wiTb-1643250160103)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0376.JPG)]

REQUIRED：如果add方法本身有事务，调用update方法之后，update方法使用当前add方法里面事务

如果add方法本身没有事务，调用update方法后，创建新事务

REQUIRED_NEW：使用add方法调用update方法，如果add无论是否有事务，都创建新的事务

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class UserService {

3、ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

（2）有三个读问题：脏读、不可重复读、虚（幻）读

（3）脏读：多事务中，一个未提交事务读取到另一个未提交事务的数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wd5VECqA-1643250160103)(file:///D:/%E4%B8%8B%E8%BD%BD/1156577092/FileRecv/MobileFile/IMG_0377.JPG?lastModify=1642827913)]

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5sHNN7VE-1643250160104)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0378.JPG)]

（5）虚读：一个未提交事务读取到另一提交事务添加数据

（6）通过设置事务的隔离级别，解决读问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aXUxjvi2-1643250160104)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0379.JPG)]

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

4、timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交就会进行回滚

（2）默认值是-1，设置时间以秒为单位进行计算

@Service
@Transactional(timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

5、readOnly：是否只读

（1）读：查询操作，写：添加修改删除操作

（2）readOnly默认值false，表示可以查询，可以添加修改删除操作

（3）设置readOnly值是true，设置成true，只能查询

6、rollbackFor：回滚

（1）设置出现哪些异常进行事务回滚

7、noRollbackFor：不回滚

（1）设置出现哪些异常不进行事务回滚

17、事务操作（XML声明式事务管理）

1、在Spring配置文件中进行配置

第一步配置事务管理器

第二步配置通知

第三步配置切入点和切面

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource">

    </property>

</bean>

<!--2 配置通知-->
<tx:advice id="txadvice">
    <!--配置事务相关参数-->

    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务-->

        <tx:method name="accountMoney" propagation="REQUIRED"/>
        <!--<tx:method name="account*"/>-->

    </tx:attributes>
</tx:advice>

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

18、事务操作（完全注解声明式事务管理）

（1）创建配置类，使用配置类替代xml配置文件

package com_kp.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.security.PublicKey;

@Configuration //配置类
@ComponentScan(basePackages = "com_kp") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {

    //创建数据库的连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/user_db?serverTimezone=UTC&&rewriteBatchedStatements=true&&useSSL=false");
        dataSource.setUsername("root");
        dataSource.setPassword("180918");
        return dataSource;

    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到ioc容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate=new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager=new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

//service类
@Service
@Transactional(readOnly = false,timeout = -1,propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

@Test
public void testAccount2(){

    ApplicationContext context=new AnnotationConfigApplicationContext(TxConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.accountMoney();
}

19、Spring5框架新功能

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

###2、Spring5.0框架自带了通用的日志封装

（1）Spring5已经移除了Log4jConfigListener,官方建议使用Log4j2

（2）Spring5框架整合Log4j2

第一步引入jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pWEo51ll-1643250160104)(D:/Typora/image/Snipaste_2022-01-22_21-15-10.png)]

第二步创建log4j2.xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!--日志级别以及优先级排序:OFF > FATAL > ERROR > WARN > INFO >DEBUG > TRACE >ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <console name="Console" target="SYSTEM OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root:用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

3、Spring5框架核心容器支持@Nullable注解

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

（2）注解用在方法上面，方法返回值可以为空

@Nullable
String getId();

（3）注解使用在方法参数里面，方法参数可以为空

public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier, BeanDefinitionCustomizer... customizers) {
    this.reader.registerBean(beanClass, beanName, supplier, customizers);
}

（4）注解使用在属性上面，属性值可以为空

@Nullable
private String bookName;

4、Spring5核心容器支持函数式风格GenericApplicationContext

//函数式风格创建对象，交给spring进行管理
//用spring5的新功能，通过lambda表达式把对象在里面做注册
@Test
public void testGenericApplicationContext(){
    //1 创建GenericApplicationContext对象
    GenericApplicationContext context=new GenericApplicationContext();
    //2 调用context的方法对象注册
    context.refresh();
    context.registerBean(/*法二："user1",*/User.class,() ->new User());
    //3 获取在spring注册的对象,对象名不是默认小写user
    User user = (User) context.getBean("com_kp.test.User");
    //法二：User user =(User) context.getBean("user1");
    System.out.println(user);
}

20、Spring5框架新功能：支持整合JUnit5

（1）整合JUnit4

第一步引入Spring相关针对测试依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nIGT7vK-1643250160104)(D:/Typora/image/Snipaste_2022-01-23_13-18-47.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7wgU3g2I-1643250160105)(D:/Typora/image/Snipaste_2022-01-23_13-29-45.png)]

第二步创建测试类，使用注解方式完成

package com_kp.test;

import com_kp.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
@ContextConfiguration("classpath:bean1.xml") //加载配置文件
public class JTest4 {

    @Autowired
    private UserService userService;

    @Test
    public void test1(){
        userService.accountMoney();
    }
}

（2）Spring5整合JUnit5

第一步引入JUnit5的jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fzu9atDv-1643250160105)(D:/Typora/image/Snipaste_2022-01-23_13-34-08.png)]

第二步创建测试类，使用注解完成

package com_kp.test;

import com_kp.service.UserService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
public class JTest5 {

    @Autowired
    private UserService userService;

    @Test
    public void test1(){
        userService.accountMoney();
    }
}

21、Spring5框架新功能-Webflux

1、SpringWebflux介绍

（1）是Spring5添加新的模块，用于web开发的，功能SpringMVC类似的，Webflux使用当前一种比较流程响应式编程出现的框架。

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WbtCpbIT-1643250160106)(D:/Typora/image/Snipaste_2022-01-23_14-59-06.png)]

（3）解释什么是异步非阻塞

异步同步
非阻塞和阻塞

** 上面都是针对对象不一样

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

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

（4）Webflux特点：

第一非阻塞式：在有限的资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程。

第二函数式编程：Spring5框架基于java8，Webflux使用Java8函数式编程方式实现路由请求。

（5）比较SpringMVC

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2CaJRIWW-1643250160106)(D:/Typora/image/Snipaste_2022-01-23_15-57-55.png)]

第一两个框架都可以使用注解方式，都运行在Tomcat等容器中。

第二 SpringMVC采用命令式编程，WebFlux采用异步响应式编程（两者可随时切换，Webflux在有限的时间内能处理更多请求，可实现远程服务调用，微服务网关）。

2、响应式编程

（1）什么是响应式编程？

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

电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

（2）Java8及其之前版本

提供的观察者模式的两个类Observer和Observable

package com.webflux.demoreactor8.reactor8;

import java.util.Observable;

public class ObserverDemo extends Observable {
    public static void main(String[] args) {
        ObserverDemo observer=new ObserverDemo();
        //添加观察者
        observer.addObserver((o,arg)->{
            System.out.println("发生变化");
        });
        observer.addObserver((o,arg)->{
            System.out.println("手动被观察者通知，准备改变");
        });
        observer.setChanged();//数据变化
        observer.notifyObservers();//通知
    }
}

3、响应式编程（Reactor实现）

（1）响应式编程操作中，满足Reactive规范框架

（2）Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，提供丰富的操作符。Flux对象实现发布者，返回N个元素；Mono实现发布者，返回0或者1个元素。

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z2PB8u66-1643250160106)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0381.JPG)]

（4）代码演示Flux和Mono

第一步引入依赖

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

第二步编写代码

package com.webflux.demoreactor8;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class TestReactor {

    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);

        Stream<Integer> stream=list.stream();
        Flux.fromStream(stream);
    }
}

（5）三种信号特点

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

（6）调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的。subscribe

//just方法直接声明
Flux.just(1,2,3,4).subscribe(System.out::print);
Mono.just(1).subscribe(System.out::print);

（7）操作符

对数据流进行一道道操作，成为操作符，比如工厂流水线
第一 map 元素映射为新元素
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2fDldrei-1643250160107)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0383.JPG)]
第二 flatMap 元素映射为流
- 把每个元素转换为流，把转换之后多个流合并大的流
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aiodJXbn-1643250160107)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0384.JPG)]

4、SpringWebflux执行流程和核心API

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

（1）Netty

*** BIO 阻塞方式**

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cAVtwG8B-1643250160107)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0385.JPG)]

*** NIO 非阻塞方式**

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TcTb1rBc-1643250160107)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0386.JPG)]

（2）SpringWebflux 执行过程和 SpringMVC 是相似的

*** SpringWebflux核心控制器 DispatchHandler，实现接口WebHandler**

*** 接口 WebHandler 有一个方法**

package org.springframework.web.server;

import reactor.core.publisher.Mono;

public interface WebHandler {
    Mono<Void> handle(ServerWebExchange var1);
}

public Mono<Void> handle(ServerWebExchange exchange) {  // 放http请求响应信息
    return this.handlerMappings == null ? this.createNotFoundError() : Flux.fromIterable(this.handlerMappings).concatMap((mapping) -> {
        return mapping.getHandler(exchange); // 根据请求地址获取对应mapping
    }).next().switchIfEmpty(this.createNotFoundError()).flatMap((handler) -> {
        return this.invokeHandler(exchange, handler);// 调用具体的业务方法
    }).flatMap((result) -> {
        return this.handleResult(exchange, result);// 处理结果返回
    });
}

（3）SpringWebflux里面DispatcherHandler，负责请求的处理

*** HandlerMapping：请求查询到处理的方法**

*** HandlerAdapter：真正负责请求处理**

*** HandlerResultHandler：响应结果处理**

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

5、SpringWebflux（基于注解编程模型）

SpringWebflux实现方式有两种：注解编程模型和函数式编程模型

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

第一步创建SpringBoot工程，引入Webflux依赖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mPpD79rr-1643250160108)(D:/Typora/image/Snipaste_2022-01-26_16-06-41.png)]

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

第二步配置启动端口号

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QOdsP1u5-1643250160108)(D:/Typora/image/Snipaste_2022-01-26_16-08-55.png)]

第三步创建包和相关类

实体类

package com.entity;

public class User {
    private String name;
    private String gender;
    private Integer age;

    public User(String name,String gender,Integer age){
        this.name=name;
        this.gender=gender;
        this.age=age;
    }

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

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender;
    }

    public Integer getAge() {
        return age;
    }
}

*** 创建接口定义操作的方法**

package com.service;

import com.entity.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

//用户操作接口
public interface UserService {
    //根据id查询用户（0或1个元素用Mono）
    Mono<User> getUserById(int id);

    //查询所有用户（多个元素用Flux）

    Flux<User> getAllUser();

    //添加用户
    Mono<Void> saveUserInfo(Mono<User> user);
}

*** 接口实现类**

package com.service.Impl;

import com.entity.User;
import com.service.UserService;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.HashMap;
import java.util.Map;


public class UserServiceImpl implements UserService {


    //创建map集合存储数据
    private final Map<Integer,User> users=new HashMap<>();

    public UserServiceImpl(){
        this.users.put(1,new User("Lucy","nan",20));
        this.users.put(2,new User("Mary","nv",30));
        this.users.put(3,new User("Jack","nan",50));
    }

    //根据id查询
    @Override
    public Mono<User> getUserById(int id) {
        return Mono.justOrEmpty(this.users.get(id));
    }

    //查询多个用户
    @Override
    public Flux<User> getAllUser() {
        return Flux.fromIterable(this.users.values());
    }

    //添加用户
    @Override
    public Mono<Void> saveUserInfo(Mono<User> userMono) {
        return userMono.doOnNext(person -> {
            //向map集合里面放值
            int id=users.size()+1;
            users.put(id,person);
        }).thenEmpty(Mono.empty());
    }
}

*** 创建controller**

package com.controller;


import com.entity.User;
import com.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
public class UserController {
    
    //注入service
    @Autowired
    private UserService userService;
    
    //id查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserId(@PathVariable int id){
        return userService.getUserById(id);
    }
    
    //查询所有
    @GetMapping("/user")
    public Flux<User> getUser(){
        return userService.getAllUser();
    }
    
    //添加操作
    @PostMapping("/saveuser")
    public Mono<Void> saveUser(@RequestBody User user){
        Mono<User> userMono=Mono.just(user);
        return userService.saveUserInfo(userMono);
    }
}

*** 说明：SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat**

SpringWebflux方式，异步非阻塞方式，基于SpringWebflux+Reactor+Netty

6、SpringWebflux（基于函数式编程模型）

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

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

（3）SpringWebflux请求和响应不再是ServletRequest和ServletResponse，而是ServerRequest和ServerResponse

第一步把注解编程模型工程复制一份

第二步创建 Handler （具体实现方法）

package com.handler;

import com.entity.User;
import com.service.UserService;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import static org.springframework.web.reactive.function.BodyInserters.fromObject;

public class UserHandler {
    
    private final UserService userService;
    public UserHandler(UserService userService){
        this.userService=userService;
    }
    
    //根据id查询
    public Mono<ServerResponse> getUesrById(ServerRequest request){
        //获取id值
        int userId = Integer.valueOf(request.pathVariable("id"));//强转
        //空值处理
        Mono<ServerResponse> notFound=ServerResponse.notFound().build();
        //调用service方法得到数据
        Mono<User> userMono = this.userService.getUserById(userId);
        //把userMono进行转换返回
        //使用Reactor操作符flatMap
       return userMono
               .flatMap(person->ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                       .body(fromObject(person)))
                        .switchIfEmpty(notFound);
    }
    
    //查询所有
    public Mono<ServerResponse> getAllUsers(){
        //调用service得到结果
        Flux<User> users = this.userService.getAllUser();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }
    
    //添加
    public Mono<ServerResponse> saveUser(ServerRequest request){
        //得到user对象
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
    }   
}

第三步初始化服务器，编写Router

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qY16jaXW-1643250160108)(D:/下载/1156577092/FileRecv/MobileFile/IMG_0387.JPG)]

*** 创建路由的方法**

public class Server {

    //1 创建Router路由
    public RouterFunction<ServerResponse> routingFunction(){
        //创建handler对象
        UserService userService=new UserServiceImpl();
        UserHandler handler=new UserHandler(userService);
        //设置路由
        return RouterFunctions.route(
                GET("/users/{id}").and(accept(MediaType.APPLICATION_JSON)),handler::getUesrById)
                .andRoute(GET("/users").and(accept(MediaType.APPLICATION_JSON)),handler::getAllUsers);
    }
}

*** 创建服务器完成适配**

//2 创建服务器完成适配
public void createReactorServer(){
    //路由和handler适配
    RouterFunction<ServerResponse> route = routingFunction();
    HttpHandler httpHandler = toHttpHandler(route);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
    
    //创建服务器
    HttpServer httpServer=HttpServer.create();
    httpServer.handle(adapter).bindNow();
}

*** 最终调用**

public static void main(String[] args) throws IOException {
    Server server=new Server();
    server.createReactorServer();
    System.out.println("enter to exit");
    System.in.read();
}

（4）使用WebClient调用

package com.service;

import com.entity.User;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;

public class Client {

    public static void main(String[] args) {
        //调用服务器地址
        WebClient webClient=WebClient.create("http://127.0.0.1:24253");
        //根据id查询
        String id="1";
        User userresult = webClient.get().uri("/users/{id}", id)
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class)
                .block();
        System.out.println(userresult.getName());

        //查询所有
        Flux<User> result = webClient.get().uri("/users").accept(MediaType.APPLICATION_JSON)
                .retrieve().bodyToFlux(User.class);
        result.map(stu->stu.getName())
                .buffer().doOnNext(System.out::println).blockFirst();//blockFirst相当于订阅
    }
}

Setsail0918

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring5

Spring51、spring是什么？Spring是轻量级的开源的JavaEE框架，解决了企业应用开发的复杂性，两个核心部分：IOC和AOP，但还有其他如事务、MVC等功能。Spring为简化企业级应用开发而生，使用Spring可以使简单的JavaBean实现以前只有EJB才能实现的功能。Spring是一个IOC(DI)和AOP容器框架。Spring框架主要由七部份组成分别是Spring Core、Spring AOP、Spring ORM、Spring DAO、Spring Context、S
复制链接

扫一扫