Spring注解开发、AOP、声明式事务(狂神)

常用依赖

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

8.使用注解开发

1.bean

在Spring4之后，要使用注解开发，必须要保证aop的包导入了
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cY7zXtPR-1629855753895)(img.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>

2.属性如何注入

//等价于 <bean id="user" class="com.kuang.pojo.User"/>
//@Component 组件
@Component
public class User {
  //public String name = "秦";
  //@Value相当于
  /*<property name="name" value="秦"/>*/
  @Value("kuang")
  public String name;

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

3.衍生的注解

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

• dao层 @Repository

• service层@Service

• controller层 @Controller

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

4.自动装配

@Autowired 自动装配通过类型.名字
如果Autowired不能唯一自动装配属性,则需要通过@Qulifier(value=“xxx”)

• @Nullable 字段标记了这个注解,说明这个字段可以为null
• @Resource 自动装配通过名字,类型
• @Component 组件，放在类上，说明这个类被Spring管理了，就是bean！

5.作用域

@Component
//@Scope("singleton")
@Scope("protoType")
public class User {
    //public String name = "秦";
    //@Value相当于
    /*<property name="name" value="秦"/>*/
    @Value("kuang")
    public String name;
    @Value("ku")
    public void setName(String name) {
        this.name = name;
    }
}

@Scope(“protoType”)

6.小结

xml与注解：

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

xml与注解最佳实践：

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

9.使用Java方式配置Spring

我们现在要完全不使用Spring的XML配置了，全权交给Java来做！

JavaConfig是Spring的一个子项目，在Spring4之后成为了核心功能；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-THFwghQP-1629855753898)(img_2.png)]
实体类

package com.kuang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这个注解的意思，就是说明这个类被Spring托管了，注册到了容器中；
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("qin")//属性注入值
    public void setName(String name) {
        this.name = name;
    }

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

配置类

package com.kuang.config;

import com.kuang.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.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {

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

    }


}

测试类

import com.kuang.config.KuangConfig;
import com.kuang.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(KuangConfig.class);
        User getUser = context.getBean("getUser", User.class); //方法名就是bean的名字；
        System.out.println(getUser.getName());
    }
}

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

10.代理模式（讲AOP前先学代理模式）

为什么学习代理模式？因为这就是SpringAOP的底层！{面试SpringAOP 和 SpringMVC}

代理模式的分类：

• 静态代理；
• 动态代理；
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQC4EsuR-1629855753901)(img_3.png)]

10.1静态代理

角色分析：

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

代码步骤
1.接口

package com.kuang.demo1;
//租房
public interface Rent {
    public void rent();

}

2.真实角色

package com.kuang.demo1;
//房东 要去租房 所以要继承出租房的接口
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子");

    }
}

3.代理角色

package com.kuang.demo1;

public class Proxy implements Rent{
    private Host host;//优先使用组合而不是继承

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

    public Proxy() {
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        heTong();
        fare();

    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void heTong(){
        System.out.println("签租赁合同");

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

4.客户端访问代理角色

package com.kuang.demo1;

public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //host.rent();
        //中介代理房东，中介帮房东出租房子，但是，代理角色一般会有附属操作
        Proxy proxy = new Proxy(host);
        //你不用找房东，找中介即可
        proxy.rent();
    }
}

代理模式的好处：

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

代理模式的缺点：

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

10.2加深理解

代码：com.kuang.demo2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qpeP1ruY-1629855753904)(img_4.png)]

10.3动态代理

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

需要了解两个类：Proxy、InvocationHandler(调用)

动态代理的好处：

• 静态代理好处他都有
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务；
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可；

11.AOP

https://www.cnblogs.com/slivelove/p/10882195.html

11.1 什么是AOP

11.2 AOP在Spring中的作用

11.3 使用Spring实现AOP

使用AOP需要先导入一个依赖包。

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

方式一：使用Spring的API接口(主要是SpringAPI接口实现)

方式二：使用自定义来实现AOP(主要是切面定义)

方式三：使用注解实现

12.整合mybatis（学过mybatis再学这块）

12.1回忆mybatis

1.编写实体类

2.编写核心配置文件

3.编写接口

4.编写Mapper.xml

5.测试

13.声明式事务（学过mybatis再学这块）

13.1 回顾事务

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

事务ACID原则：

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

13.2Spring中的事务管理

• 声明式事务：AOP；
• 编程式事务:需要在代码中进行事务的管理；

思考：为什么需要事务？

• 如果不配置事务，可能存在数据提交不一致的情况；
• 如果我们不在Spring中配置声明式事务，就需要在代码中手动配置事务
• 事务在项目开发中十分重要！涉及到数据的一致性和完整性问题，不容马虎！！