Spring学习笔记

1. Spring

1.1 简介

  • Spring：春天---->给软件行业带来的春天

  • spring理念：使现有的的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

  • SSH：Struct2 + Spring + Hibernate

  • SSM：SpringMVC + Spring + Mybatis

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

1.2 优点

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

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

1.3 组成

1616815053357

1.4 拓展

在Spring的官网有这个介绍：现代化的Java开发！说白就是基于Spring的开发！

1616815254194

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

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

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

2. IOC理论推导

  1. UserDao接口
  2. UserDaoImpl实现类
  3. UserService业务接口
  4. UserServiceImpl实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！

如果代码量十分大，修改一次的代价会十分昂贵！

我们使用一个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）

3. HelloSpring

1、applicationContext.xml,为了简便这里命名为"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">

    <!--使用spring来创建对象，在spring中这些都成为Bean-->
    <bean id="hello" class="com.cao.pojo.Hello">
        <property name="str" value="Hello_Spring"></property>
    </bean>

</beans>

2、实例化容器

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

4. IOC创建对象的方式

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

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

    1. 下标赋值

      <!--下标赋值-->
<bean id="user" class="com.cao.pojo.User">
    <constructor-arg index="0" value="caoshikui"></constructor-arg>
</bean>

    2. Constructor argument name

      <bean id="user" class="com.cao.pojo.User">
    <constructor-arg name="name" value="shikuciao"></constructor-arg>
</bean>

    3. Constructor argument type matching （不建议使用）

      <bean id="user" class="com.cao.pojo.User">
    <constructor-arg type="java.lang.String" value="曹仕奎"></constructor-arg>
</bean>

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

5. Spring配置

5.1 别名

<!--如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"></alias>

5.2 Bean的配置

<!--
        id：     bean 的唯一标识符，也就是相当于我们学的对象名
        class：  bean 对象所对应的全限定名：包名 + 类型
        name：   也是别名，而且 name 可以同时取多个别名（user u2 u3,u4;u5）
        -->
<bean id="user2" class="com.cao.pojo.User">
    <constructor-arg name="name" value="曹仕奎"></constructor-arg>
</bean>

5.3 import

import 一般用于团队开发，它可以将多个配置文件导入合并为一个

假设现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的配置文件

  • 张三
  • 李四
  • 王五
  • applicationContext

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

如果存在id相同的bean，那么前面的会被后面的覆盖

6. 依赖注入

6.1 构造器注入

前面4.IOC创建对象的方式已经讲述

6.2 通过set方式注入【重点】

  • 依赖注入：set注入！
  • 注入：bean对象中的所有属性，有容器来注入！

【环境搭建】

  1. 复杂类型

    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[] book;

    private List<String> hobbies;

    private Map<String,String> map;

    private Set<String> games;

    private Properties info;

    private String wifeName;
}

  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.cao.pojo.Student">
        <property name="name" value="caoshikui"></property>
        <property name="wifeName" value="zhangyue"></property>
    </bean>
</beans>

  4. 测试类

    public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }
}

  5. 完善注入信息

    <?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.cao.pojo.Address">
        <property name="address" value="江西南昌"></property>
    </bean>

    <bean id="student" class="com.cao.pojo.Student">
        <!-- 第一种：普通值注入 -->
        <property name="name" value="caoshikui"></property>
        <property name="wifeName" value="zhangyue"></property>

        <!-- 第二种：Bean注入，ref -->
        <property name="address" ref="address"></property>

        <!--array-->
        <property name="book">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>

        <!--list-->
        <property name="hobbies">
            <list>
                <value>篮球</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>

        <!--map-->
        <property name="map">
            <map>
                <entry key="身份证" value="123123123132"></entry>
                <entry key="银行卡" value="789789798789"></entry>
            </map>
        </property>

        <!--set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>dnf</value>
            </set>
        </property>

        <!--Properties-->
        <property name="info">
            <props>
                <prop key="学号">411014519005</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>
</beans>

6.3 拓展方式注入

6.3.1 官方文档

我们使用p命名空间（Set）和 c：（构造）命名空间去注入

地址： https://docs.spring.io/spring/docs/5.2.7.RELEASE/spring-framework-reference/core.html#beans-c-namespace

p-namespace

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

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.cao.pojo.User" p:name="caoshikui" p:age="23"></bean>
</beans>

c-namespace

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

    <!--c命名空间注入，通过构造器注入：constructor-args-->
    <bean id="user2" class="com.cao.pojo.User" c:_0="23" c:_1="shikuicao">

    </bean>
</beans>

注意：p命名和c命名空间不能直接使用，需要导入xml约束

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

6.4 bean的作用域

1616836379516

  1. singleton

    <bean name="user" class="com.cao.pojo.User" p:name="caoshikui" scope="singleton"/>

    默认是单例模式

  2. The Prototype Scope

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

    <bean name="user" class="com.cao.pojo.User" p:name="caoshikui" scope="prototype"/>

  3. 其余的Request、Session、Application、websocket 只有在web开发中使用到

7. Bean的自动装配

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

在Spring中有三种自动装配的方式

  1. 在xml中显式配置
  2. 在Java中显式配置
  3. 隐式的自动装配Bean【重要】

7.1 测试

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

dog

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

cat

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

people

public class People {
    private Dog dog;
    private Cat cat;
    private String name;

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "dog=" + dog +
                ", cat=" + cat +
                ", name='" + name + '\'' +
                '}';
    }
}

7.2 ByName自动装配

<!--
  byName:会自动在容器上下文查找，和自己对象set方法后面的值对应的 beanid！    
-->
<bean id="people" class="com.cao.pojo.People" autowire="byName">
    <property name="name" value="caoshikui" ></property>
</bean>

7.3 ByType自动装配

<!--
    byType:会自动在容器上下文查找，和自己对象属性类型相匹配的 beanid！
 -->
<bean id="people" class="com.cao.pojo.People" autowire="byType">
    <property name="name" value="caoshikui" ></property>
</bean>

小结：

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

7.4 使用注解实现自动装配

jdk1.5开始支持注解，Spring2.5就支持了

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML. The shortanswer is “it depends.”（基于注释的配置的引入提出了这样一个问题:这种方法是否比XML“更好”。简短的回答是“视情况而定”。

要使用注解须知：

  1. 导入约束context约束(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/>

    <bean id="dog" class="com.cao.pojo.Dog"></bean>
    <bean id="cat" class="com.cao.pojo.Cat"></bean>
    <bean id="people" class="com.cao.pojo.People"/>

</beans>

  3. 自动装配

    • @Autowired

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

      import org.springframework.beans.factory.annotation.Autowired;
public class People {
	private Cat cat;
	@Autowired //加在属性上
	private Dog dog;
	private String name;
	@Override
	public String toString() {
		return "People{" +
			"cat=" + cat +
			", dog=" + dog +
			", name='" + name + '\'' +
		'}';
	}
	public Cat getCat() {
		return cat;
	}
	@Autowired //加在set方法上使用！
        public void setCat(Cat cat) {
        this.cat = cat;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

      同时Autowired也可不必写set方法，前提是自动装配的对象在IOC容器中。其符合byType，也就是说beans.xml的BeanId可以不和要配置的属性名一致，比如：

      <bean id="dog111" class="com.cao.pojo.Dog"></bean>

      注意，大部分是说先按byType，然后有相同时再byName

    • @Qualifier

      如果@Autowired自动装配的环境比较复杂，自动装配无法通过@Autowired完成时，需要配合@Qualifier取添加限定符，指定一个bean对象注入

      public class People {
    @Autowired
    @Qualifier(value = "dog2")
    private Dog dog;

    @Autowired
    @Qualifier(value = "cat1")
    private Cat cat;
	...
}

    • @Resource

      集成了@Autowired和@Qualifier，但在大部分开发中不怎么实用，因为效率较前者低

      public class People {
    @Resource(name = "dog2")
    private Dog dog;

    @Resource(name = "cat1")
    private Cat cat;
	...
}

      <!--开启注解支持-->
    <context:annotation-config/>

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

  4. 总结

    @Resource 和 @Autowired

    • 都是用来自动装配的，都可以放在属性的字段上
    • 1616844476844
    • @Autowired 通过byType方式实现，而且要求这个对象必须存在【常用】
    • @Resource 默认通过byName方式实现，如果找不到名字，则通过byType实现，如果两个都找不到就报错
    • 执行顺序不同：@Autowired 通过byType方式实现；@Resource 默认通过byName方式实现

8. 使用注解开发

在spring4之后，要使用注解开发，必须保证AOP的包导入了

使用注解需要导入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>

  1. bean

    // 等价于<bean id="user" class="com.cao.pojo.User"/>
// @Component 组件

  2. 属性如何注入

    @Component
public class User {
    /*
    @Value注解相当于：
    <bean id="user" class="com.cao.pojo.User">
        <property name="name" value="caoshikui-zhangyue"></property>
    </bean>
    */
    @Value("shikuicao-zhangyue")
    public String name;

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

  3. 衍生的注解

    • @Component：组件，放在类上，说明这个类被Spring管理了，就是bean。

      该注解有一些衍生注解，我们在web开发中，会按照mvc三层架构分层

    • dao 【@Repository】

    • service 【@Service】

    • controller【@Controller】

    这4个注解的功能都是一样的，都是代表将其给类注册的的IOC容器中，然后装配bean

  4. 自动装配

    • @Autowired

    • @Nullable

    • Resoutce

  5. 作用域

    • 单例模式 @Scope("singleton")
    • 原型模式@Scope("Prototype")

小结

xml 和 注解 对比

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

xml 和 注解 的最佳实践

  • xml用来管理bean

  • 注解用来注入属性

  • 在使用过程中要注意，要让注解生效的话，需要开启注解的支持和扫包

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

9. 使用Java的方式取配置Spring

现在我们完全不使用Spring的xml配置，全都交给Java来做

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

Java实体类

package com.cao.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

// 这里这个注解的意思：说明此类被Spring接管，注册到了IOC容器中
@Component
public class User {
    // 注入值
    @Value("shikuicao")
    private String name;

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

    public String getName() {
        return name;
    }

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

配置文件（配置类）

// 这个也会被Spring容器托管，因为他本来就是一个@Component
// @Configuration 代表这是一个配置类，就和我们之前看的bean.xml一样
@Configuration
@ComponentScan("com.cao.pojo")
@Import(CaoConfig2.class)
public class CaoConfig {
    // 注册一个bean，相当于之前写的bean标签
    // 这个方法名字就相当于bean标签中的id属性
    // 这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();// 就是返回要注入到bean的对象
    }
}

测试类

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

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

10. 代理模式

为什么学习代理模式？因为这就是SpringAOP的底层。SpringAOP和SpringMVC面试必问

代理模式的分类：

  • 静态代理
  • 动态代理

10.1 静态代理

角色分析：

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

代理模式的好处：

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

缺点：

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

步骤：

  1. 接口

    public interface Rent {
    public void rent();
}

  2. 真实角色

    // 房东
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租！");
    }
}

  3. 代理角色

    public class Proxy implements Rent{
    private Host host;

    public Proxy(Host host) {
        this.host = host;
    }

    public Proxy() {
    }

    @Override
    public void rent() {
        host.rent();
    }

    public void seeHouse(){
        System.out.println("中介带看房");
    }

    public void fair(){
        System.out.println("中介收费");
    }

    public void sign(){
        System.out.println("中介签合同");

    }
}

  4. 客户端访问代理角色

    public class Client {
    public static void main(String[] args) {
        // 房东要出租
        Host host = new Host();
        // 代理，中介帮房东出租
        // 代理角色会有一些附属操作，例如看房，收费，签合同
        Proxy proxy = new Proxy(host);

        // 不用面对房东，找中介即可
        proxy.rent();
    }
}

10.2 静态代理2

AOP

1616902399286

10.3 动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的
  • 动态代理分为两大类：1.基于接口的动态代理 2.基于类的动态代理
    • 基于接口-----jdk的动态代理【使用这个】
    • 基于类：cglib
    • Java字节码实现：javassist

需要了解两个类，Proxy，InvocationHandler

动态代理的好处：

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

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

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

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

  • 一个动态代理类可以代理多个类，只要实现了统一规格接口即可

案例

  1. 接口

    public interface UserService {
    public void add();

    public void delete();

    public void update();

    public void query();
}

  2. 真实角色

    // 真实对象
public class UserServiceImpl implements UserService {

    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }
}

  3. 代理角色

    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 setTarget(Object target) {
        this.target = target;
    }

    // 生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    // 处理代理实力，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质就是使用反射机制
        Object result = method.invoke(target, args);
        return result;
    }
}

  4. 客户端访问

    public class Client {
    public static void main(String[] args) {
        // 真实对象
        UserServiceImpl userService = new UserServiceImpl();
        // 代理
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        // 设置代理的对象，即userService
        pih.setTarget(userService);
        // 动态的生成代理对象
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

11. AOP

11.1 什么是AOP

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

11.2 AOP在Spring中的作用

声明式事务：允许用户自定义切面

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

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

11.3 使用Spring实现AOP

首先需要导入包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

方法一：通过Spring API实现【主要是SpringAPI接口实现】

业务接口

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

业务接口的实现类

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("查询了一个用户");
    }
}

业务增强类，这里举一个前置增强和后置增强的例子

public class BeforeLog implements MethodBeforeAdvice {
    // method:要执行的目标对象的方法
    // Object：参数
    // target: 目标对象
    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法");
    }
}

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"放回结果为"+returnValue);
    }
}

然后再Spring中注册，并实现AOP切入，注意导入约束

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

    <!--注册bean-->
    <bean id="userService" class="com.cao.service.UserServiceImpl"/>
    <bean id="log" class="com.cao.log.BeforeLog"></bean>
    <bean id="afterLog" class="com.cao.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->

    <!--配置AOP:需要导入aop的约束-->
    <aop:config>
        <!--切入点 expression表达式，execution（要执行的位置！* * * *）-->
        <aop:pointcut id="pointcut" expression="execution(* com.cao.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

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【主要是切面定义】

将业务增强类替换为

public class DiyPoint {
    public void before(){
        System.out.println("方法执行前前前---------");
    }

    public void after(){
        System.out.println("方法执行后后后---------");
    }
}

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

    <!--方式二：自定义类来实现AOP-->
    <bean id="diyPoint" class="com.cao.diy.DiyPoint"></bean>
    
    <aop:config>
        <!--自定义切面，ref要引用的类-->
        <aop:aspect ref="diyPoint">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.cao.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <aop:after method="after" pointcut-ref="pointcut"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

其他不用动，但这里就不能用反射了

测试可行

方法三：使用注解实现

业务增强类

@Aspect
public class AnnotionPointCut {
    @Before("execution(* com.shanzj.service.UserServiceImpl.*(..))")
        public void before(){
        System.out.println("方法执行之前===");
    }
    @After("execution(* com.shanzj.service.UserServiceImpl.*(..))")
        public void after(){
        System.out.println("方法执行后==");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入点
    @Around("execution(* com.cao.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        System.out.println(joinPoint.getSignature());
        Object proceed = joinPoint.proceed();
        System.out.println("环绕后");
    }
}

applicationcontext.xml

<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"
    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 id="annotionPointCut" class="com.cao.diy.AnnotionPointCut"/>
    <!--开启注解支持 JDK(默认proxy-target-class="false") cglib(proxy-target-class="true")-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

12. 整合Mybatis

步骤

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

12.1 回忆mybatis

  1. 编写实体类

    @Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

  2. 编写核心配置文件

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"></properties>
    <typeAliases>
        <package name="com.cao.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"></property>
                <property name="url" value="${url}"></property>
                <property name="username" value="${username}"></property>
                <property name="password" value="${password}"></property>
            </dataSource>
        </environment>
    </environments>
    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/cao/mapper/UserMapper.xml" />
    </mappers>
</configuration>

    db.properties

    driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username=root
password=root

  3. 编写接口

    public interface UserMapper {
    List<User> selectUsers();
}

  4. 编写Mapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.cao.mapper.UserMapper">
    <select id="selectUsers" resultType="user">
        select * from user;
    </select>

</mapper>

  5. 测试

    @Test
public void test01() throws IOException {
    String resources = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resources);
    SqlSession sqlSession = new SqlSessionFactoryBuilder().build(inputStream).openSession(true);

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.selectUsers();
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

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

    <!--DataSource：使用Spring的数据源替换Mybatis的配置

        我们这里使用spring提供的jdbc
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>


    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/cao/mapper/UserMapper.xml"></property>
    </bean>

    <!--SqlSessionTemplate就是我们使用的SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory，以为他没有set方法-->
        <constructor-arg ref="sqlSessionFactory"/>
    </bean>
</beans>

  1. 编写数据源配置

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

  2. sqlSessionFactory

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/cao/mapper/UserMapper.xml"></property>
    </bean>

  3. sqlSession

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能使用构造器注入sqlSessionFactory，以为他没有set方法-->
    <constructor-arg ref="sqlSessionFactory"/>
</bean>

  4. 将userMapper的接口实现类注入到Spring中去

    <bean id="userMapper" class="com.cao.mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

  5. 测试

    @Test
public void test02(){
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
    UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
    List<User> users = userMapper.selectUsers();
    for (User user : users) {
        System.out.println(user);
    }
}

    在这里就不用再spring-dao.xml中去写SqlSessionTemplate，即sqlSession就省略了

13. 声明式事务

13.1 回顾事务

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

事务ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能同时操作同一个资源，要防止数据损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化到存储器中！

13.2 Spring中的事务管理器

  • 声明式事务：AOP横切进去的不需要改原有代码
  • 编程式事务：需要改动代码进行事务管理

思考：

为什么要配置事务？

  • 如果不配置，可能存在数据提交不一致的情况
  • 如果我们不在Spring中去配置生命是事务，就需要在代码中手动配置事务
  • 事务在项目的开发中十分重要
posted on 2021-03-29 18:24  caoshikui  阅读(62)  评论(0)    收藏  举报