标签：spring void 代理 public Spring class

1 spring

1.1 简介

spring：春天 —->给软件行业带来了春天
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
很难想象Rod Johnson的学历，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
Spring理念：使现有技术更加实用 .本身就是一个大杂烩 , 整合现有的框架技术
SSM : SpringMvc+Spring+Mybatis

官方下载地址：https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub ：https://github.com/spring-projects

导包

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

</dependencies>

1.2 优点

Spring是一个开源免费的框架 ( 容器 ) .
Spring是一个轻量级的框架，非侵入式的 .
控制反转 IoC ，面向切面编程 Aop
对事物的支持 , 对框架的支持

一句话概括：Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器（框架）。

1.3 拓展

Spring Boot与Spring Cloud

Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
Spring Cloud是基于Spring Boot实现的;
Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架;
Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置， Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

2、IOC

2.1、什么是IOC？

传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；

2.2、分析传统项目实现

1、写一个UserDao接口

2、UserDao的实现类

3、UserService业务接口

4、Service的业务实现类

package service.impl;import dao.UserDao;import dao.impl.UserDaoMysqlImpl;
import service.UserService;
public class UserServiceImpl implements UserService {  
    //1、传统方法，直接new对象  
    private UserDao userDao = new UserDaoMysqlImpl();
    public void getUser()  {       
        userDao.getUser();  
    }

在我们之前的业务中，用户的需求困难影响我们原来的代码，需要修改代码才可以实现切换具体的实现类，这种做法耦合性太高了，扩展性不好！假设我们的这种需求非常大 , 这种方式就根本不适用了,比较容易出错。

我们如何解决这个问题？

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

public class UserServiceImpl implements UserService {   
    private UserDao userDao;    // 利用set实现   
    public void setUserDao(UserDao userDao) {      
        this.userDao = userDao;  
    }

从上面来看，代码灵活了许多。以前代码都是固定的，现在是由我们选择程序去创建对象。选择权是我们手上。

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

2.3、IOC本质

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

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3 HelloSpring

1、写实体类

package com.lei.pojo;

/**
 * @author lei
 * @verson:1.8
 */
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 + '\'' +
                '}';
    }
}

2、在资源目录下编写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">
     <!--    使用Spring来创建对象，在Spring这些都称为Bean

     类型   变量名 = new 类型（）
     Hello hello = new Hello

     id = 变量名 =hello
     class = new 的对象
     property 相当于给对象中的属性设置一个值

       ref：引用Spring容器中创建好的对象
       value ：具体的值 基本数据类型
       -->
    <bean id="hello" class="com.lei.pojo.Hello">
        <property name="str" value="Spring" />
    </bean>
</beans>

3、测试

import com.lei.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author lei
 * @verson:1.8
 */
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());
    }
}

结果：

3.2、为什么不用new就可以使用

Hello 对象是谁创建的 ? 为什么不用new就可以使用?
- hello 对象是由Spring创建的，交给了spring管理了，使用的时候通过spring去获取就能使用了
Hello 对象的属性是怎么设置的 ?
- hello 对象的属性是由Spring容器设置的。

这个过程就叫控制反转

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

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

到了现在 , 我们彻底不用再程序中去改程序了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改即可，这就是所谓的IoC，简单来说 : 对象由Spring 来创建 , 管理 , 装配 !

4 IOC创建方式

1.使用无参构造创建参数

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

1 下标赋值

<!-- 第一种下标赋值-->
  <bean id="user" class="com.lei.pojo.User">
     <constructor-arg index="0" value="磊"/>
  </bean>
</beans>

2通过类型创建不建议使用

 <bean id="user" class="com.lei.pojo.User">
        <constructor-arg type="java.lang.String" value="qqq"/>
   </bean>

3 通过参数名（建议使用）

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

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

5 Spring配置

5.1 别名

<!--别名-->
    <alias name="user" alias="user2"/>

5.2 Bean的配置

<!-- 
   id ：bean的标识符 相当于我们学的对象名
   class： bean 对象所对应的全限定名 
   name： 也是别名 name更高级 可以同时起多个名字-->
     <bean class="com.lei.pojo.User" id="user" name="user3">

5.3import

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

6 DI 依赖注入

6.1 构造器注入


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

6.2 set方式注入（重点）

依赖注入：Set注入
- 依赖：bean对象依赖于容器
- 注入：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[] books;
    private List<String> hobbys;
    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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="address" class="com.lei.pojo.Address">
        <property name="address" value="西安"/>
    </bean>
    <bean id="student" class="com.lei.pojo.Student">
         <!--普通值注入-->
        <property name="name" value="磊"/>
        <!--Bean注入-->
        <property name="address" ref="address"/>
        <!--数组注入  -->
        <property name="books">
            <array>
                <value>单位</value>
                <value>西游记</value>
            </array>
        </property>
        <!--list注入  -->
        <property name="hobbys">
            <list>
                <value>唱歌</value>
                <value>跳舞</value>
            </list>
        </property>
        <!--map注入  -->
        <property name="card">
            <map>
                <entry key="身份证" value="1111111111111111"/>
                <entry key="手机号" value="12345678912"/>
            </map>
        </property>
        <!--set注入  -->
        <property name="games" >
            <set>
                <value>lol</value>
                <value>bob</value>
            </set>
        </property>
        <!--properties  -->
        <property name="wife">
            <null/>
        </property>
        <property name="info">
            <props>
                <prop key="学号">2104007100</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>
</beans>

4.测试类

public class MyText {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
   /*结果
   Student{
     name='磊',
     address=Address{address='西安'},
     books=[单位, 西游记],
     hobbys=[唱歌, 跳舞],
     card={
       身份证=1111111111111111,
       手机号=12345678912
     },
     games=[lol, bob],
     wife='null',
     info={
       学号=2104007100,
       性别=男
     }
    }
    */
    }
}

6.3拓展方式注入

可以通过p命名空间和c命名空间

使用

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    
<!--     p命名空间 可以直接注入属性的值 property-->
    <bean id="user" class="com.lei.pojo.User" p:name="d" p:anInt="18"/>
<!--    c命名空间 可以通过构造器注入 constructor-arg-->
    <bean id="user1" class="com.lei.pojo.User" c:name="磊" c:anInt="18"/>
</beans>

测试

@Test
public void t(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = (User) context.getBean("user1");
    System.out.println(user);
}

6.4 bean的作用域（ bean scope）

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

scope="singleton"

<bean id="user1" class="com.lei.pojo.User" c:name="磊" c:anInt="18" scope="singleton"/>

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

scope="prototype"

<bean id="user1" class="com.lei.pojo.User" c:name="磊" c:anInt="18" scope="prototype"/>

3.其余在web开发中使用

7 Bean的自动装配

自动装配是使用spring满足bean依赖的一种方法
spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中三种装配机制，分别是：
1. 在XML中显式配置;
2. 在java中显式配置;
3. 隐式的自动装配bean【重要】

7.1 测试

1 环境：一个人有两个动物

7.2 byName自动装配

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

</bean>

7.3 byType自动装配

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

</bean>

小结：

byname的时候，需要保证所以bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致

byType的时候，需要保证所以bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

7.4 使用注解实现自动装配

jdk1.5支持注解 spring 2.5支持

要使用注解须知

1.导入约束。 context约束

2.配置注解的支持 context:annotation-config/

<?xml version="1.0" encoding="UTF-8"?>
<?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-3.0.xsd">

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

@Autowired 自动装配通过类型，名字

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

使用Autowired 可以不用使用set方法从ioc容器中找先按类型 bytype 后名字 byname来实现的

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

如果 @Autowired 不能唯一自动装配属性，则需要@Qualifier(value = " ")搭配使用

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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--     指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.lei.pojo"  />
    <context:annotation-config/>
</beans>

1.bean

2.属性如何注入

//@Component=<bean id="user" class="com.lei.pojo.User"/>
@Component  组件
public class User {
// 相当于<property name="name" value="ss"/>
    @Value("ss")
    public String name;
}

3.衍生的注解

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

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

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

4.自动装配

@Autowired 自动装配通过类型，名字
@Nullable 字段标记了这个注解，说明这个字段可以为null

5.作用域

@Scope

6 小结

xml与注解

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

XML与注解整合开发：推荐最佳实践

xml管理豆
注解完成属性注入
使用过程中，可以不用扫描，扫描是为了类上的注解

<context:annotation-config/>

作用：

进行注解驱动注册，从而使注解生效
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
如果不扫描包，就需要手动配置bean
如果不加注解驱动，则注入的值为null！

9 使用java的方式配置Spring

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，

在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能。

实体类

//这个也会被Spring容器托管，注册到容器中
public class User {
    private String name;

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

配置文件

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

}

测试

public class Mtext {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LeiConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }
}

10 代理模式

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

代理模式分类

静态代理
动态代理

10.1 静态代理

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现
真实角色 : 被代理的角色
代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
客户 : 使用代理角色来进行一些操作 .

代码步骤

1.接口

public interface Rent {
    public void rent();
}

2.真实角色

 // 房东类 真实角色
public class Host  implements Rent{
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3.代理角色

public class Proxy  implements Rent{
    private Host host;

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

    public void rent() {
        seeHouse();
        host.rent();
        hetong();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void hetong(){
        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、静态代理的好处

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .

缺点 :

类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

代码

10.3动态代理

动态代理的角色和静态代理的一样 .
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理——JDK动态代理
- 基于类的动态代理—cglib
- 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
- 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy ，

【InvocationHandler：调用处理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
    //参数 
    //proxy - 调用该方法的代理实例 
    //method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。 
    //args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

 * 我们会用这个类，自动生成代理类
 */
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

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

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质，就是使用反射
        Object result = method.invoke(rent, args);
        return result;
    }
}

10.4、动态代理的好

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

11、AOP

11.1 什么是AOP

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

11.2 Aop在Spring中的作用

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

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

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

即 Aop 在不改变原有代码的情况下 , 去增加新的功能 .

11.3 使用Spring实现Aop

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

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

第一种方式通过 Spring API 实现

首先编写我们的业务接口和实现类

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

public class UserServiceImp implements UserService{
    public void add() {
        System.out.println("增加");
    }

    public void update() {
        System.out.println("修改");
    }

    public void select() {
        System.out.println("查询");
    }

    public void delect() {
        System.out.println("删除");
    }
}

日志类

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()+"被执行了");

    }
}

//returnValue  返回结果
public class AfterLog  implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) 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 https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="userService" class="com.lei.service.UserServiceImp"/>
<bean id="log" class="com.lei.log.Log"/>
    <bean id="aferlog" class="com.lei.log.AfterLog"/>

<!--    配置aop-->
    <aop:config>
<!--        切入点 expressio:表达式 execution（要执行的位置 !） -->
        <aop:pointcut id="pointcut" expression="execution(* com.lei.service.UserServiceImp.*(..))"/>

<!--        执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="aferlog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

结果
![屏幕截图 2022-11-04 214106](D:\java笔记\spring\屏幕截图 2022-11-04 214106.png)

第二种自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

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

去spring中配置

<!--第二种方式自定义实现--><!--注册bean-->
<bean id="diy" class="com.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>   
    <!--第二种方式：使用AOP的标签实现-->  
    <aop:aspect ref="diy">  
        <aop:pointcut id="diyPonitcut" expression="execution(* com.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>  
        <aop:after pointcut-ref="diyPonitcut" method="after"/>   
    </aop:aspect>
</aop:config>

第三种使用注解实现aop

/**
 * @author lei
 * @verson:1.8
 */
@Aspect    //标注这个类是一个切面
public class Ann {
    @Before("execution(* com.lei.service.UserServiceImp.*(..))")
    @After("execution(* com.lei.service.UserServiceImp.*(..))")
    public void before(){
        System.out.println("=======方式执行前");
    }
}

!--    使用注解-->
    <bean id="Ann" class="com.lei.diy.Ann"/>
<!--    开启注解支持-->
    <aop:aspectj-autoproxy/>
<!--    使用sping-->
<bean id="userService" class="com.lei.service.UserServiceImp"/>
<bean id="log" class="com.lei.log.Log"/>
    <bean id="aferlog" class="com.lei.log.AfterLog"/>

12 整合Mybatis

步骤：

1.导入相关jar包

junit
mybatis
mysql数据库
spring
aop
mybatis-spring

Mybatis-spring

1.编写数据源配置

<?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">
<!--使用spring配置jdbc 数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="0414"/>
    </bean>
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
<!--        绑定mybatis配置文件-->
        <property name="configLocation" value="mybatis-cofing.xml"/>
        <property name="mapperLocations" value="classpath:com/lei/mapper/*.xml"/>
    </bean>

    <!--注册sqlSessionTemplate , 关联sqlSessionFactory-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--利用构造器注入-->
        <constructor-arg ref="sqlSessionFactory"/>
    </bean>
</beans>

2.sqlSessionFactory

3.SqlSessionTemplate

4.需要给接口添加实现类【】

/**
 * @author lei
 * @verson:1.8
 */
public class UserMapperImp implements Usermapper {
//使用SqlSessionTemplate来执行
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        Usermapper mapper = sqlSession.getMapper(Usermapper.class);
        return mapper.selectUser();
    }
}

5.测试

public class MyTest {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Usermapper userMapper = context.getBean("userMapper", Usermapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

13 声明式事务

1 回顾事务

要么都成功，要么都失败
事务在开发中非常重要，涉及到数据的一致性问题，不能马虎
确保完整性和一致性

事务ACID原则：

原子性
一致性
隔离性：防止事务损坏
持久性：事务一旦提交，无论系统发生什么问题

13 声明式事务

声明事务：AOP

<!--    配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    结合aop实现事务的织入-->
<!--    配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--        给那些方法配置事务-->
<!--        配置事务的传播特性-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delect" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

<!--    配置事务切入点-->
    <aop:config>
        <aop:pointcut id="txPoinCut" expression="execution(* com.lei.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoinCut"/>
    </aop:config>
</beans>

标签：spring,void,代理,public,Spring,class
From： https://www.cnblogs.com/lei0/p/16870877.html

spring

1 spring

1.1 简介

1.2 优点

1.3 拓展

2、IOC

2.1、什么是IOC？

2.2、分析传统项目实现

2.3、IOC本质

3 HelloSpring

4 IOC创建方式

5 Spring配置

5.1 别名

5.2 Bean的配置

5.3import

6 DI 依赖注入

6.1 构造器注入

6.2 set方式注入（重点）

6.3拓展方式注入

6.4 bean的作用域（ bean scope）

7 Bean的自动装配

7.1 测试

7.2 byName自动装配

7.3 byType自动装配

7.4 使用注解实现自动装配

8 使用注解开发

9 使用java的方式配置Spring

10 代理模式

10.1 静态代理

10.2、静态代理的好处

10.3动态代理

10.4、动态代理的好

11、AOP

11.1 什么是AOP

11.2 Aop在Spring中的作用

11.3 使用Spring实现Aop

第一种方式通过 Spring API 实现

第二种自定义类来实现Aop

第三种使用注解实现aop

12 整合Mybatis

Mybatis-spring

13 声明式事务

相关文章

赞助商

阅读排行