Spring学习过程

Spring

总结于狂神说java
他讲的很好，观看推荐

简介

• spring：春天—>给软件行业带来了春天

• 2002，首次推出了Spring框架的雏形：interface21框架！

• Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版。

• Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
  Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

• SSH：Struct2 + Spring + Hibernate!

• SSM：SpringMVC + Spring + Mybatis!

  官网：https://spring.io/projects/spring-framework#overview
  官方下载地址：https://repo.spring.io/release/org/springframework/spring/
  GitHub：https://github.com/spring-projects/spring-framework

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.7</version>
</dependency> 
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

优点

• Spring是一个开源的免费的框架
• Spring是一个轻量级，非入侵式的框架
• 控制反转（IOC），面向切面编程（AOP）
• 支持事物的处理，对框架整合的支持

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

组成

拓展

现代化的Java开发！说白就是基于Spring的开发！

• Spring Boot
  • 一个快速开发的脚手架。
  • 基于SpringBoot可以快速的开发单个微服务。
  • 约定大于配置。
• Spring Cloud
  • SpringCloud是基于SpringBoot实现的。

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱！”

IOC理论推导

UserDao 接口

public interface UserDao {
    void getUser();
}

UserDaoImpl 实现类

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("默认获取用户数据");
    }
}

UserService 业务接口

public interface UserService {
    void getUser();
}

UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
        public void getUser() {
        userDao.getUser();
    }
}

测试

public class MyTest {
	public static void main(String[] args) {
	   //用户实际调用的是业务层，dao层他们不需要接触！
	    UserService userService = new UserServiceImpl();
    	userService.getUser();
	}
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

我们使用一个Set接口实现，已经发生了革命性的变化！

private UserDao userDao;

//利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

之前，程序是主动创建对象！控制权在程序猿手上！
使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象！
这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型！

IOC本质

控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。

HelloSpring

新建一个maven项目，编写实体类

package com.yeshen.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
            "str='" + str + '\'' +
            '}';
    }
}

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

    <!-- 使用Spring创建对象，在Spring这些称为Bean
        id=变量名
        class=new的对象
        property 给对象中的属性设置一个值
        ref:引用Spring容器中创建好的对象
        value：具体的值，基本数据类型
     -->
    <bean id="hello" class="com.yeshen.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //对象现在都在Spring中管理了，需要使用，可以直接取出来
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

思考问题？

• Hello对象是谁创建的？
• Hello对象是由Spring创建的。
• Hello对象的属性是怎么设置的？
• Hello对象的属性是由Spring容器设置的。
• 这个过程就叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而变成被动的接收对象。

依赖注入：就是利用set方法来进行注入的。

IOC是一种编程思想，由主动的编程变成被动的接收。

可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。

OK，到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！

IOC创建对象方式

1. 使用无参构造创建对象，默认

2. 假设使用有参构造创建对象

   1. 下标赋值

      <bean id="user" class="com.yeshen.pojo.User">
          <constructor-arg index="0" value="钱"/>
      </bean>
      

   2. 通过类型创建

      <!--  通过类型创建，不建议使用  -->
      <bean id="user" class="com.yeshen.pojo.User">
          <constructor-arg type="java.lang.String" value="前"/>
      </bean>
      

   3. 直接通过参数名设置

      <!--  直接通过参数名设置  -->
      <bean id="user" class="com.yeshen.pojo.User">
          <constructor-arg name="name" value="芊"/>
      </bean>
      

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

Spring配置

别名

<!--  别名，如果添加了别名，，可以使用别名取到对象 （在我目前看来，没什么用）  -->
<alias name="user" alias="userNew"/>

Bean的配置

<!--
   id:bean的唯一标识符，相当于对象名
   class：bean对象所对应的全限定名：包名+类型
   name:也是别名。并且name可以同时取多个别名
   -->
<bean id="userT" class="com.yeshen.pojo.UserT" name="u2 user2,us2:use2">
    <property name="name" value="南方车站"/>
</bean>

import

这个import一般用于团队开发

假设项目中有多个人开发，三个人负责不同的开发，不同的类需要注册不同的bean中，可以利用import将所有人的beans.xml

合并为一个总的

• 张三

• 李四

• 王五

• applicationContext,.xml

  <import resource="beans1.xml"/>
  <import resource="beans2.xml"/>
  <import resource="beans3.xml"/>
  

使用的时候，直接使用总的配置就可以了

DI依赖注入

构造器注入

前面已经说过了

Set方式注入【重点】

• 依赖注入：Set注入
  • 依赖：bean对象的创建依赖于容器
  • 注入：bean对象中的所有属性，由容器注入

【环境搭建】

1. 复杂类型

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

2. 真实测试对象

   
   public class Student {
       private String name;
       private Address address;
       private String[] books;
       private List<String> hobbies;
       private Map<String,String> card;
       private Set<String> games;
       private String wife;
       private Properties info;
   
   

3. beans.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd">
   
       <bean id="student" class="com.yeshen.pojo.Student">
           <!--    第一种，普通值注入，value    -->
           <property name="name" value="签"/>
       </bean>
   
   </beans>
   

4. 测试类

   public class MyTest {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           Student student = (Student) context.getBean("student");
   
           System.out.println(student.getName());
       }
   }
   

完善注入信息

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

    <bean id="address" class="com.yeshen.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.yeshen.pojo.Student">
        <!--   普通值注入，value  -->
        <property name="name" value="签"/>
        <!--   bean注入，ref  -->
        <property name="address" ref="address"/>
        <!--    数组注入    -->
        <property name="books">
            <array>
                <value>三国</value>
                <value>水浒</value>
                <value>西游</value>
                <value>红楼</value>
            </array>
        </property>

        <!--   List注入     -->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>game</value>
            </list>
        </property>

        <!--  Map  -->
        <property name="card">
            <map>
                <entry key="身份证" value="1231"/>
                <entry key="学生证" value="1235"/>
            </map>
        </property>
        <!--   Set     -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>CSgo</value>
            </set>
        </property>
        <!--   null     -->
        <property name="wife">
            <null></null>
        </property>
        <!--    Properties    -->
        <property name="info">
            <props>
                <prop key="学号">201811646</prop>
                <prop key="性别">男</prop>
                <prop key="username">root</prop>
                <prop key="password">123123</prop>
            </props>
        </property>
    </bean>

</beans>

拓展方式注入

可以使用p命名空间和c命名空间注入

官方解释：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rpcxwaY3-1622964648372)(C:\Users\10586\AppData\Roaming\Typora\typora-user-images\image-20210603210315574.png)]

使用：

<!--  p命名空间注入，可以直接注入属性的值：properties  -->
<!--  无参构造使用  -->
<bean id="user" class="com.yeshen.pojo.User" p:name="师父"/>

<!--  c命名空间注入，通过构造器注入：construct-args  -->
<!--  好像不能只传一个参数  -->
<bean id="user2" class="com.yeshen.pojo.User" c:name="难受" c:age="18"/>

测试：

@Test
public void test1(){
    ApplicationContext context=new ClassPathXmlApplicationContext("UserBeans.xml");
    User user = context.getBean("user", User.class);
    User user2 = context.getBean("user2", User.class);

    System.out.println(user.getName());
    System.out.println(user2.getName());
}

使用p和c 命名空间时，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

bean的作用域

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

1. 单例模式（Spring默认模式）

   <bean id="user2" class="com.yeshen.pojo.User" c:name="难受" c:age="18" scope="singleton" />
   

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

   <bean id="user2" class="com.yeshen.pojo.User" c:name="难受" c:age="18" scope="prototype" />
   

3. 其余的 request、session，application、这个只能在web中使用到

Bean的自动装配

• 自动装配是Spring满足bean依赖的一种方式
• Spring会在上下文中自动寻找，并自动给bean装配属性

在spring中有三种装配的方式

1. 在xml中显示的装配
2. 在java中显示的装配
3. 隐式的自动装配bean【重要】

测试

环境搭建：一个人有两个宠物

ByName 自动装配

<!--byName:自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id-->
<bean id="person" class="com.yeshen.pojo.Person" autowire="byName">
    <property name="name" value="夜深"/>
</bean>

ByType自动装配

<!--
byName:自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id
byType:自动在容器上下文中查找，和自己对象属性类型相同的bean
-->
<bean id="person" class="com.yeshen.pojo.Person" autowire="byType">
    <property name="name" value="夜深"/>
</bean

小结

• byName的时候，需要保证bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
• byType的时候，需要保证bean的class唯一，并且把这个bean需要和自动注入的属性的类型一致

使用注解实现自动装配

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML

使用注解须知：

1. 导入约束： xmlns:context=“http://www.springframework.org/schema/context”
2. 配置注解的支持:context:annotation-config/

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired

直接在属性上使用即可，也可以在set方法上使用

先通过ByType，再通过ByName

科普：

• @Nullable 字段标记了了这个注解，说明这个字段可以为null;

• 如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
  @Autowired(required = false)

   //如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
    @Autowired(required = false)

测试代码：

public class Person {
    //如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，可以通过使用@Qualifier(value=“xxx”)配合@Autowired的使用，指定一个唯一的bean对象注入

public class Person {
    //如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
    @Autowired(required = false)
    @Qualifier(value = "cat")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;

@Resource

public class People {
    @Resource
    private Dog dog;

    @Resource(name = "cat2")
    private Cat cat;
    private String name;

小结：

@Resource和@Autowired的区别：

• 都是用来自动装配的，都可以放在属性字段上

• @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】

• @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】

• 执行顺序不同：@Autowired通过byType的方式实现。

使用注解开发

在Spring4之后，要使用注解开发，必须保证aop包导入了

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

使用注解需要导入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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

bean

//等价于<bean id="user" class="com.yeshen.pojo.User"/>
//组件
@Component
public class User {
    public String name="yeshen";
}

属性如何注入

可以放在set方法上

public class User {
    //等同于<property name="name" value="yeshen"/>
    @Value("yeshen")
    public String name;

    //等同于<property name="name" value="yeshen"/>
 //   @Value("yeshen")
    public void setName(String name) {
        this.name = name;
    }
}

衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照MVC三层架构分层

• dao 【@Repository】
• service【@Service】
• controller 【@Controller】

这四个注解功能是一样的，都是代表将某个注册类放在Spring中，装配Bean

自动装配

@Autowired ：自动装配注解，类型，名字
    如果Autowired不能唯一自动装配上属性，则需要@Qualifier(value="xxx")配合
@Nullable  字段标记了这个注解，说明字段可以为null

@Resource ：自动装配注解，类型，名字

作用域

通过@Scope设置作用域，@Scope(value=“singleton”)设置单例

@Scope(value = "singleton")
public class User {
    //等同于<property name="name" value="yeshen"/>
    @Value("yeshen")
    public String name;

    //等同于<property name="name" value="yeshen"/>
 //   @Value("yeshen")
    public void setName(String name) {
        this.name = name;
    }
}

小结

xml与注解：

• xml更加万能，适用于任何场合，维护更简单
• 注解 不是自己类用不了，维护相对复杂

xml与注解 最佳实践：

• xml用来管理bean
• 注解只负责完成属性的注入
• 在使用的过程中，只需要注意一个问题，注解生效就必须开启注解支持

<!--  指定要扫描的包，这个包下的注解就会生效  -->
<context:component-scan base-package="com.yeshen.pojo"/>
<context:annotation-config/>

使用Java的方式配置Spring

我们现在要完全不适用Spring的xml配置，全权使用java来做

JavaConfig是Spring的一个子项目，在Spring4之后，他成为了一个核心功能

实体类

package com.yeshen.pojo;

import org.springframework.stereotype.Component;

//这个注解的意思是，说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

配置类

package com.yeshen.config;


import com.yeshen.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//这也会Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration 代表这是一个配置类，相当于之前写的beans.xml文件
@Configuration
@ComponentScan("com.yeshen.pojo")//扫描类
//@Import("")//和xml文件中的import标签效果一样
public class YeConfig {

    //注册一个bean，相当于之前写的一个bean标签
    //这个方法的名字，相当于bean标签中的id
    //这个方法的返回值，相当于bean标签中的class
    @Bean
    public User getUser(){
        return new User();//就是要返回注入到bean中的对象
    }
}

测试类

import com.yeshen.config.YeConfig;
import com.yeshen.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //如果使用配置类方式去做，我们只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(YeConfig.class);
        User getUser = (User) context.getBean("getUser");

        System.out.println(getUser.getName());
    }
}

这种纯Java的配置方式，在SpringBoot中随处可见

代理模式

为什么要学代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】

代理模式的分类：

• 静态代理
• 动态代理

静态代理

角色分析：

• 抽象角色：一般使用接口或抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，一般做一些附属操作
• 客户：访问代理对象的人

代码步骤：

1. 接口

   package com.yeshen;
   
   public interface Rent {
       //租房
       void rent();
   }
   

2. 真实角色

   package com.yeshen;
   
   public class Host implements Rent{
       @Override
       public void rent() {
           System.out.println("租房子");
       }
   }
   

3. 代理角色

   package com.yeshen;
   
   public class Proxy implements Rent{
       private Host host;
   
       public Proxy() {
       }
   
       public Proxy(Host host) {
           this.host = host;
       }
   
       @Override
       public void rent() {
           seeHouse();
           host.rent();
       }
   
       public void seeHouse(){
           System.out.println("看房子");
       }
   }
   

4. 客户端访问代理角色

   package com.yeshen;
   
   public class client {
       public static void main(String[] args) {
           //房东更要租房子
           Host host=new Host();
           //代理，中介帮房东租房子，并且加一些附加操作
           Proxy proxy = new Proxy(host);
           proxy.rent();
       }
   }
   

代理模式的好处：

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
• 公共角色就交给代理角色！实现了业务的分工！
• 公共业务发生扩展的时候，方便集中管理！

缺点：

• 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~

加深理解

代码：

1. 接口

   package com.yeshen.demo02;
   
   public interface UserService {
       void add();
       void delete();
       void update();
       void query();
   }
   

2. 实现类

   package com.yeshen.demo02;
   
   public class UserServiceImpl implements UserService{
       @Override
       public void add() {
           System.out.println("增");
       }
   
       @Override
       public void delete() {
           System.out.println("删");
       }
   
       @Override
       public void update() {
           System.out.println("改");
       }
   
       @Override
       public void query() {
           System.out.println("查");
       }
   }
   

3. 代理类

   package com.yeshen.demo02;
   
   public class UserServiceProxy implements UserService{
   
       private UserServiceImpl userService;
   
       public void setUserService(UserServiceImpl userService) {
           this.userService = userService;
       }
   
       @Override
       public void add() {
           log("add");
           userService.add();
       }
   
       @Override
       public void delete() {
           log("delete");
           userService.delete();
       }
   
       @Override
       public void update() {
           log("update");
           userService.update();
       }
   
       @Override
       public void query() {
           log("query");
           userService.query();
       }
   
       public void log(String msg){
           System.out.println("[Debug] 使用了"+msg+"方法");
       }
   }
   

4. 客户端

   package com.yeshen.demo02;
   
   public class Client {
       public static void main(String[] args) {
           UserServiceImpl userService=new UserServiceImpl();
           UserServiceProxy proxy=new UserServiceProxy();
           proxy.setUserService(userService);
           proxy.add();
       }
   
   }
   

AOP

动态代理

• 动态代理和静态代理一样
• 动态代理的代理类是动态生成的，不是我们写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口 --JDK 动态代理 【我们在这里使用】
  • 基于类 cglib
  • java字节码实现：javasist

需要连接两个类：Proxy：代理 InvocationHandler：调用处理程序

代码步骤：

1. 接口

   package com.yeshen.demo03;
   
   public interface Rent {
       //租房
       void rent();
   }
   

2. 真实角色

   package com.yeshen.demo03;
   
   public class Host implements Rent {
       @Override
       public void rent() {
           System.out.println("租房子");
       }
   }
   

3. ProxyInvovationHandler类

   package com.yeshen.demo03;
   
   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   
   //用这个类动态生成代理类
   public class ProxyInvocationHandler implements InvocationHandler {
   
       //被代理的接口
       private Object target;
   
       public void setRent(Rent rent) {
           this.target = rent;
       }
   
       //生成得到代理类
       public Object getProxy(){
           //参数  (ClassLoader,代理的接口，实现InvocationHandler的类)
           return Proxy.newProxyInstance(this.getClass().getClassLoader(), 
                                         target.getClass().getInterfaces(),this);
       }
   
       //处理代理实力，并返回结果
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           seeHouse();
           //动态代理的本质，就是使用反射实现的
           Object result = method.invoke(target, args);
   
           return result;
       }
   
       public void seeHouse(){
           System.out.println("kankan");
       }
   }
   

4. 客户端

   package com.yeshen.demo03;
   
   public class Client {
       public static void main(String[] args) {
           //真实角色
           Host host=new Host();
           //代理角色，现在没有 使用动态代理生成
           ProxyInvocationHandler pih = new ProxyInvocationHandler();
           //通过调用程序处理角色来处理接口对象
           pih.setRent(host);
   
           Rent proxy = (Rent) pih.getProxy();
           proxy.rent();
   
       }
   }
   

动态代理的好处

• 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务

• 公共角色就交给代理角色！实现了业务的分工！

• 公共业务发生扩展的时候，方便集中管理！

• 一个动态代理类代理的是一个接口，一般就是对应的一类业务

• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

AOP

什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
• 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知执行的“地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

即AOP在不改变原有代码的情况下，去增加新的功能。

使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

方式一：

使用Spring的API接口

代码：

1. 在service包下，定义UserService业务接口和UserServiceImpl实现类

   UserService.java

   package com.yeshen.service;
   
   public interface UserService {
       public void add();
       public void delete();
       public void update();
       public void select();
   }
   

   UserServiceImpl.java

   package com.yeshen.service;
   
   public class UserServiceImpl implements UserService{
       @Override
       public void add() {
           System.out.println("增加了一个用户");
       }
   
       @Override
       public void delete() {
           System.out.println("删除了一个用户");
       }
   
       @Override
       public void update() {
           System.out.println("修改了一个用户");
       }
   
       @Override
       public void select() {
           System.out.println("查询了一个用户");
       }
   }
   

2. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类

   Log.java

   package com.yeshen.log;
   
   import org.springframework.aop.MethodBeforeAdvice;
   
   import java.lang.reflect.Method;
   
   public class Log implements MethodBeforeAdvice {
       //method: 要执行的目标对象的方法
       //objects :  参数
       //o : 目标对象
       public void before(Method method, Object[] objects, Object o) throws Throwable {
           System.out.println(o.getClass().getName()+"的"+method.getName()+"方法，被执行了");
       }
   }
   

   AfterLog.java

   package com.yeshen.log;
   
   import org.springframework.aop.AfterReturningAdvice;
   
   import java.lang.reflect.Method;
   
   public class AfterLog implements AfterReturningAdvice {
       @Override
       public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
           System.out.println(o1.getClass().getName()+"的"+method.getName()+"方法，被执行了，返回结果为"+o);
       }
   }
   

3. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件

   applicationContext.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"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
   
   <!--  注册bean -->
       <bean id="userService" class="com.yeshen.service.UserServiceImpl"/>
       <bean id="log" class="com.yeshen.log.Log"/>
       <bean id="afterLog" class="com.yeshen.log.AfterLog"/>
   
       <!--  配置aop：需要导入aop的约束  -->
       <aop:config>
       <!--    切入点:expression:表达式：execution(要执行的位置* * * * *) -->
           <aop:pointcut id="pointcut" expression="execution(* com.yeshen.service.UserServiceImpl.*(..))"/>
           <!--   执行增加环绕     -->
           <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
           <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
       </aop:config>
   
   </beans>
   

4. 测试

   import com.yeshen.service.UserService;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class MyTest {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           //动态代理是接口：注意点
           UserService userService = context.getBean("userService", UserService.class);
           userService.add();
       }
   }
   

方式二

自定义实现AOP【主要是定义切面】

1. service包下的代码与方式一相同

2. 自定义切面类

   package com.yeshen.diy;
   
   public class DiyPointCut {
       public void before(){
           System.out.println("=========方法前=========");
       }
       public void aftere(){
           System.out.println("=========方法后=========");
       }
   }
   

3. 配置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"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
           
   <!--  注册bean -->
       <bean id="userService" class="com.yeshen.service.UserServiceImpl"/>
       <bean id="log" class="com.yeshen.log.Log"/>
       <bean id="afterLog" class="com.yeshen.log.AfterLog"/>
       <bean id="diyPointCut" class="com.yeshen.diy.DiyPointCut"/>
       
   <aop:config>
       <aop:aspect ref="diyPointCut">
           <aop:pointcut id="point" expression="execution(* com.yeshen.service.UserServiceImpl.*(..))"/>
           <aop:before method="before" pointcut-ref="point"/>
           <aop:after method="aftere" pointcut-ref="point"/>
       </aop:aspect>
   </aop:config>
   

4. 测试

   import com.yeshen.service.UserService;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class MyTest {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           //动态代理是接口：注意点
           UserService userService = context.getBean("userService", UserService.class);
           userService.add();
       }
   }
   

方式三：

使用注解实现

1. 自定义切面类

   package com.yeshen.diy;
   
   import org.aspectj.lang.ProceedingJoinPoint;
   import org.aspectj.lang.annotation.After;
   import org.aspectj.lang.annotation.Around;
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   
   @Aspect//标注这个类是一个切面
   public class AnnotationPointCut {
   
       @Before("execution(* com.yeshen.service.UserServiceImpl.*(..))")
       public void before(){
           System.out.println("执行前");
       }
   
       @After("execution(* com.yeshen.service.UserServiceImpl.*(..))")
       public void after(){
           System.out.println("执行后");
       }
   
       @Around("execution(* com.yeshen.service.UserServiceImpl.*(..))")
       public void around(ProceedingJoinPoint jp) throws Throwable {
           System.out.println("环绕前");
           Object proceed = jp.proceed();//执行方法
           System.out.println("环绕后");
       }
   }
   

2. xml文件

       <bean id="apc" class="com.yeshen.diy.AnnotationPointCut"/>
   	<!--    开启注解支持-->
       <aop:aspectj-autoproxy/>
   

3. 测试结果

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

整合Mybatis

步骤：

1. 导入相关jar包
   • junit
   • mysql数据库
   • mybatis
   • spring相关的
   • aop织入
   • mybatis-spring
2. 编写配置文件
3. 测试

Mybatis-Spring

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

整合实现一：

1. 引入Spring配置文件spring-dao.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"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
   </beans>
   

2. 配置数据源替换mybaits的数据源

   <!-- DataSource:使用Spring数据源替换Mybatis的配置
       这里使用Spring提供的JDBC: org.springframework.jdbc.datasource.DriverManagerDataSource
   -->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
       <property name="username" value="root"/>
       <property name="password" value="hadoop"/>
   </bean>
   

3. 配置SqlSessionFactory，关联MyBatis

   <!--  sqlSessionFactory  -->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>
       <!--   绑定mybatis配置文件     -->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
       <property name="mapperLocations" value="classpath:com/yeshen/mapper/*.xml"/>
   </bean>
   

4. 注册sqlSessionTemplate，关联sqlSessionFactory

   <!--  SqlSessionTemplate  就是我们使用的sqlSession  -->
   <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
       <!--   通过构造器注入     -->
       <constructor-arg index="0" ref="sqlSessionFactory" />
   </bean>
   

5. 需要UserMapper接口的UserMapperImpl 实现类，私有化sqlSessionTemplate

   package com.yeshen.mapper;
   
   import com.yeshen.pojo.User;
   import org.mybatis.spring.SqlSessionTemplate;
   
   import java.util.List;
   
   public class UserMapperImpl implements UserMapper{
   
       //以前，我们所有的操作，都使用sqlSession来执行，现在都使用sqlSessionTemplate;
       private SqlSessionTemplate sqlSessionTemplate;
   
       public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
           this.sqlSessionTemplate = sqlSessionTemplate;
       }
   
       @Override
       public List<User> getUserList() {
           UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
           return mapper.getUserList();
       }
   }
   

6. 将自己写的实现类，注入到Spring配置文件中

   <!--  将实现类注册到bean中  -->
   <bean id="userMapper" class="com.yeshen.mapper.UserMapperImpl">
       <property name="sqlSessionTemplate" ref="sqlSession"/>
   </bean>
   

7. 测试使用即可！

   public class MyTest {
       @Test
       public void test() throws IOException {
           ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
           UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
           List<User> userList = userMapper.getUserList();
           for (User user : userList) {
               System.out.println(user);
           }
       }
   }
   

声明式事务

回顾事务

• 把一组业务当成一个业务来做；要么都成功，要么都失败！
• 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
• 确保完整性和一致性。

事务ACID原则：

• 原子性（atomicity）
  • 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
• 一致性（consistency）
  • 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
• 隔离性（isolation）
  • 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
• 持久性（durability）
  • 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

配置文件

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"
//       xmlns:p="http://www.springframework.org/schema/p"  使用命名空间时加
//       xmlns:c="http://www.springframework.org/schema/c"	使用命名空间时加
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           https://www.springframework.org/schema/beans/spring-beans.xsd">


</beans>

per.getUserList();
}
}

6. 将自己写的实现类，注入到Spring配置文件中

```xml
<!--  将实现类注册到bean中  -->
<bean id="userMapper" class="com.yeshen.mapper.UserMapperImpl">
    <property name="sqlSessionTemplate" ref="sqlSession"/>
</bean>

7. 测试使用即可！

   public class MyTest {
       @Test
       public void test() throws IOException {
           ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
           UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
           List<User> userList = userMapper.getUserList();
           for (User user : userList) {
               System.out.println(user);
           }
       }
   }
   

声明式事务

回顾事务

• 把一组业务当成一个业务来做；要么都成功，要么都失败！
• 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
• 确保完整性和一致性。

事务ACID原则：

• 原子性（atomicity）
  • 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
• 一致性（consistency）
  • 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
• 隔离性（isolation）
  • 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
• 持久性（durability）
  • 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

配置文件

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"
//       xmlns:p="http://www.springframework.org/schema/p"  使用命名空间时加
//       xmlns:c="http://www.springframework.org/schema/c"	使用命名空间时加
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           https://www.springframework.org/schema/beans/spring-beans.xsd">


</beans>