spring框架总结

1. Spring是什么？及其特点。

　　Spring框架是一个开源的轻量级容器框架。主要有三大特点：

　　(1) 容器。Spring框架是一个容器，能够管理项目中的所有对象。

　　(2) IOC（控制反转）。Spring将创建对象的方式反转了，从程序员自己创建反转给了程序。

　　　　DI（依赖注入） 需要有IOC环境，在Spring创建Bean对象时，动态的将依赖对象注入到Bean对象中去。依赖注入和控制反转最大的好处就是解耦合。

　　(3) AOP（面向切面）。面向切面编程，简而言之，就是将纵向重复的代码横向抽取出来,主要体现在为容器中管理的对象生成动态代理对象。

2. applicationContext & BeanFactory区

　　BeanFactory

　　　　BeanFactory是一个接口，用来实例化、配置和管理Bean对象，里面有一个getBean()方法获取Bean对象。

　　　　　　 使用BeanFactory(拿到Bean对象) 三种方法：

　　　　　　　　方式一：根据id拿，可以确定

　　　　　　　　方式二：也是根据id和Class实例，可以确定(不需要强转)

　　　　　　　　方式三：根据类型，现在有两个类型相等，无法确定(报错)

//第一步:拿到资源配置文件
		Resource resource = new ClassPathResource("applicationContext.xml");
		//第二步：拿到核心对象 BeanFactory
		BeanFactory factory = new XmlBeanFactory(resource);
		
		//通过BeanFactory获取Bean对象的三种方式：
			//第一种：通过xml文件中配置的id获取对象
			Object bean1 = factory.getBean("ud");
			((UserDaoImpl)bean1).add();

			//第二种：通过xml文件中配置的id及类的字节码对象 获取对象
			UserDaoImpl bean2 = factory.getBean("ud",UserDaoImpl.class);
			bean2.add();

			//第三种：通过类的字节码对象 获取对象.
			UserDaoImpl bean3 = factory.getBean(UserDaoImpl.class);
			bean3.add();	//依赖注入(DI)/控制反转(IOC)
			
			//三种方式拿到的Bena对象在内存中的地址都相同
			System.out.println(bean1==bean2 && bean2==bean3);//true

　　　　以上三种方式是spring框架底层拿对象的方式，我们不会去用这些方式去直接获取bean对象
　　　　获取spring核心对象的首选方式:
　　　　ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
　　　　//通过该对象的getBean()获取具体的bean对象
　　　　UserDaoImpl bean4 = ac.getBean("ud",UserDaoImpl.class);
　　　　UserDaoImpl bean5 = ac.getBean("ud",UserDaoImpl.class);
　　　　System.out.println(bean4 == bean5);   //true

区别：

　　　　 1.  ApplicationContext是BeanFactory的子类,拥有更多的功能与方法。比如：提供了文本信息解析工具，包括I18N（国际化）的支持；提供了载入文件资源的通用方法；提供了发送事件的功能。

　　　　2.   ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。

　　　　　　而BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。

　　　　3. BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。

　　扩展：我们在使用ApplicationContext的时候，可以通过配置让它也变成与BeanFactory一样的懒加载：

　　　　配置一：让所有Bean都变成懒加载

　　　　<beans xmlns="http://www.springframework.org/schema/beans"

　　　　....

　　　　default-lazy-init="true">

　　　　　　<bean id="myBean" class="cn.itsource._01_hello.MyBean"></bean>

　　　　</beans>　　　

　  　配置二：让其中一个Bean变成懒加载

　　    <bean id="myBean" class="cn.itsource._01_hello.MyBean" lazy-init="true"></bean>

 

 3. 请解释Spring Bean的生命周期？

先简单了解：

生命周期属性(了解)———初始化和销毁
    (1)配置一个方法作为生命周期初始化方法,spring会在对象创建之后立刻调用 init-method
    (2)配置一个方法作为生命周期的销毁方法,spring容器在关闭并销毁所有容器中的对象之前调用destory-method
    <bean init-method=“init”  destory-method=“destory”></bean>        对应注解为@PostConstruct

    <bean name=“hello” class=“完整类名”></bean>                                 对应注解为@PreDestory

Spring中Bean的管理是其最基本的功能，根据下面的图来了解Spring中Bean的生命周期：

解说：

（1）BeanFactoryPostProcessor的postProcessorBeanFactory()方法：若某个IoC容器内添加了实现了BeanFactoryPostProcessor接口的实现类Bean，那么在该容器中实例化任何其他Bean之前可以回调该Bean中的postPrcessorBeanFactory()方法来对Bean的配置元数据进行更改，比如从XML配置文件中获取到的配置信息。

（2）Bean的实例化：对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。

（3）Bean属性注入：实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成依赖注入。

（4）BeanNameAware的setBeanName()方法：如果某个Bean实现了BeanNameAware接口，那么Spring将会将Bean实例的ID传递给setBeanName()方法，在Bean类中新增一个beanName字段，并实现setBeanName()方法。

（5）BeanFactoryAware的setBeanFactory()方法：如果某个Bean实现了BeanFactoryAware接口，那么Spring将会将创建Bean的BeanFactory传递给setBeanFactory()方法，在Bean类中新增了一个beanFactory字段用来保存BeanFactory的值，并实现setBeanFactory()方法。

（6）ApplicationContextAware的setApplicationContext()方法：如果某个Bean实现了ApplicationContextAware接口，那么Spring将会将该Bean所在的上下文环境ApplicationContext传递给setApplicationContext()方法，在Bean类中新增一个ApplicationContext字段用来保存ApplicationContext的值，并实现setApplicationContext()方法。

（7）BeanPostProcessor预初始化方法：如果某个IoC容器中增加的实现BeanPostProcessor接口的实现类Bean，那么在该容器中实例化Bean之后，执行初始化之前会调用BeanPostProcessor中的postProcessBeforeInitialization()方法执行预初始化处理。

（8）InitializingBean的afterPropertiesSet()方法：如果Bean实现了InitializingBean接口，那么Bean在实例化完成后将会执行接口中的afterPropertiesSet()方法来进行初始化。

（9）自定义的inti-method指定的方法：如果配置文件中使用init-method属性指定了初始化方法，那么Bean在实例化完成后将会调用该属性指定的初始化方法进行Bean的初始化。

（10）BeanPostProcessor初始化后方法：如果某个IoC容器中增加的实现BeanPostProcessor接口的实现类Bean，那么在该容器中实例化Bean之后并且完成初始化调用后执行该接口中的postProcessorAfterInitialization()方法进行初始化后处理。

（11）使用Bean：此时有关Bean的所有准备工作均已完成，Bean可以被程序使用了，它们将会一直驻留在应用上下文中，直到该上下文环境被销毁。

（12）DisposableBean的destory()方法：如果Bean实现了DisposableBean接口，Spring将会在Bean实例销毁之前调用该接口的destory()方法，来完成一些销毁之前的处理工作。

（13）自定义的destory-method指定的方法：如果在配置文件中使用destory-method指定了销毁方法，那么在Bean实例销毁之前会调用该指定的方法完成一些销毁之前的处理工作。

 4. 解释Spring支持的几种bean的作用域。

Spring容器中的bean可以分为5个范围：   scope属性

（1）singleton：默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护。

（2）prototype：多例原型:  被标识为多例的对象,每次在获得才会被创建,每次创建都是新的对象.

（3）request：Web环境下,对象与request生命周期一致 .

（4）session：Web环境下,对象与session生命周期一致.

（5）global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

总结:绝大多数情况下，使用单例singleton(默认值)，但是在与struts整合时候，务必要用prototype多例，因为struts2在每次请求都会创建一个新的Action，若为单例，在多请求情况下，每个请求找找spring拿的都是同一个action。

5. Spring框架中的单例Beans是线程安全的么？

  Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的Spring bean并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”。

6、Spring如何处理线程并发问题？

在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域，因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理，解决线程安全问题。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获取锁，没获得锁的线程则需要排队。而ThreadLocal采用了“空间换时间”的方式。

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

 7. 注解将对象注册到Spring容器当中，有几种注解方式？它们有什么区别吗？

4种。配置在类上方的注解分别是：@Component()   普通的注解:用于三层外的bean的配置.   @Service()  业务层 .   @Controller() web层中使用 .     @Respository()//持久层.

Spring框架最早出现的只有@Component()注解，但如果所有的对象都使用同一个注解，很难区分对象究竟属于哪一层架构。基于此，Spring又推出了@Service()、@Controller()、@Respository()三种注解，用于区分对象属于哪一层架构。但4种注解方式从功能上来说没有任何区别。

8. 如何用注解的方式来完成属性注入？

　　1. 在需要使用注解进行的时候，需要在配置文件中进行 开启注解扫描的配置

　　　　<!--开启注解的扫描　扫描com.gs下所有的包-->
　　　　<context:component-scan base-package="com.gs" />
　　　　 <!-- 开启Spring的注解的扫描：@Controller @Service @Repository @Component等 。默认存在-->
　　　　<context:annotation-config />

      2. 按类型分可以分为值类型注入和引用类型注入。

　　　　值类型注入可以通过@Value()注解来完成，该注解既可以声明在属性上，也可以声明在方法上，建议声明在方法上，但是更多的人会声明在属性上，因为更方便。

　　　　引用类型注入可以通过三种注解方式来完成:　　　　　　　　　　　　

　　　　　　配置在属性上的注解

　　　　　　　　　　@Resource   javax包下的一个注解,功能更加强大点

　　　　　　　　　　@Autowired

　　　　　　　　　　@Qualifier 属性注入时通知spring容器注入何种类型的对象（告诉spring容器对象的id（name））注意:在使用注解的方式下 及 一个接口下有多个实现类的时候 结合@Autowird一起使用

　　　　　　　　　　　　

 9. Spring框架中，什么注解可以用来指定对象的作用范围？    和怎么导入其他spring配置文件

答：@Scope(scopeName=”singleton”)。

模块化配置,即分模块配置(导入其他spring配置文件)
<beans>
    <import resource = “spring配置文件的全路径名” />
</beans>

 10、Spring的自动装配。

Spring中bean有三种装配机制，分别是：1. 在xml中显示配置、 2. 在java中显示配置，  3.  隐式的bean发现机制和自动装配。

set注入和构造注入有时在做配置时比较麻烦。所以框架为了提高开发效率，提供自动装配功能，简化配置。

Spring自动化装配可以借助@Autowired属性实现，以下是自动装配@Autowired属性的六个值的简要介绍：

　　（1）no：默认的方式是不进行自动装配的，通过手工设置ref属性来进行装配bean。

　　（2）byName：通过bean的名称进行自动装配，如果一个bean的 property 与另一bean 的name 相同，就进行自动装配。 

　　（3）byType：通过参数的数据类型进行自动装配。　　　

 　　　　　缺点：如果存在多个相同类型的bean对象，会出错。

       　　　　　　 如果属性为单一类型的数据，那么查找到多个关联对象会发生错误。

       　　　　        如果属性为数组或集合(泛型)类型，那么查找到多个关联对象不会发生异常。

　　（4）constructor：利用构造函数进行装配，并且构造函数的参数通过byType进行装配。

　　（5）autodetect：自动探测，如果有构造方法，通过 construct的方式自动装配，否则使用 byType的方式自动装配。
　　（6）default  ：表示默认采用上一级标签的自动装配的取值。如果存在多个配置文件的话，那么每一个配置文件的自动装配方式都是独立的。 

11.spring中 有哪些依赖注入方式？

　　1. 使用属性的setter方法注入 . (可用于注入bean、字面量、集合；如果是新项目，建议使用Spring注解，因为一堆一堆的xml不好维护，同时功能也不如注解强大。)

属性注入要求Bean提供一个默认的无参的构造函数(否则使用属性注入时将抛出异常)，并为需要注入的属性提供对应的Setter方法。Spring先调用Bean的默认构造函数实例化Bean对象，然后通过反射的方式调用Setter方法注入属性值。

看下简单的例子：

Car类 ：定义了3个属性，并分别提供了对应的Setter方法。
属性注入要求Bean提供一个默认的构造函数，并为需要注入的属性提供对应的Setter方法。
Spring先调用Bean的默认构造函数实例化Bean对象，然后通过反射的方式调用Setter方法注入属性值。

package com.spring.model;

public class Car {
    
    private int maxSpeed;
    private String brand;
    private double price;
    
    public int getMaxSpeed() {
        return maxSpeed;
    }
    //一定要写被注入对象的set方法
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    
    public void run(){
        System.out.println("brand:"+brand+",maxSpeed:"+maxSpeed+",price:"+price);
    }
}

在Spring配置文件中对Car进行属性注入：

<!-- 属性注入 -->
<bean id="car" class="com.spring.model.Car">  
    <property name="maxSpeed" value="200"></property>
    <property name="brand" value="红旗CA72"></property>  
    <property name="price" value="200000.00"></property>
</bean>

测试方法：

@Test
public void test(){
    //读取配置文件
    ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean的实例
    Car car=(Car) ctx.getBean("car");
    car.run();
}

 2.构造函数注入

使用方式：
第一，在类中，不用为属性设置setter方法，但是需要生成该类带参的构造方法。
第二，在配置文件中配置该类的bean，并配置构造器，在配置构造器中用到了<constructor-arg>节点，该节点有四个属性：
· index是索引，指定注入的属性，从0开始；
· type是指该属性所对应的类型；
· ref 是指引用的依赖对象（关联另一个bean）

· value 当注入的不是依赖对象，而是基本数据类型时，就用value；

看下简单的例子：
User.java

package com.gs.依赖注入;

public class User {
    private String username;
    private String password;
    private Friend friend;
    
    public String getUsername() {
        return username;
    }
    
    public String getPassword() {
        return password;
    }
    
    public Friend getFriend() {
        return friend;
    }
    
    public User() {
        super();
    }
    public User(String username, String password, Friend friend) {
        super();
        this.username = username;
        this.password = password;
        this.friend = friend;
    }
    
    
}

   Friend.java

package com.gs.依赖注入;

public class Friend {
    private String name = "张三12345";

    public String getName() {
        return name;
    }

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

    public Friend() {
        super();
    }

    public Friend(String name) {
        super();
        this.name = name;
    }
    
}

Spring配置文件

<bean id="user" class="com.gs.依赖注入.User">
    <!-- 通过索引注入值 -->
<!--     <constructor-arg index="0" value="admin"/>
        <constructor-arg index="1" value="66666"/>
        <constructor-arg>
                <bean class="com.gs.依赖注入.Friend"/>
        </constructor-arg>
-->    
    
    <!-- 通过形参名称注入值 -->
<!--    <constructor-arg name="username" value="李四"/>
        <constructor-arg name="password" value="123456"/> 
        <constructor-arg>
                <bean class="com.gs.依赖注入.Friend"/>
        </constructor-arg>
-->    
    
    <!-- 通过形参类型注入值 -->
        <constructor-arg type="java.lang.String" value="123456"/>
        <constructor-arg type="java.lang.String" value="lisi"/>
        <constructor-arg>
                <bean class="com.gs.依赖注入.Friend"/>
        </constructor-arg> 
</bean>

3.XML自动注入

简化spring的配置文件：

 配置方案

　　根节点beans   default-autowire="byName" 对当前配置文件的所有bean都生效

　　子节点bean autowire="byType"只对当前bean生效

 

1. 按照属性的名：bean里提供定义一个属性，提供 setXxx方法   

         default-autowire="byName"         配置文件的bean的id必须和代码bean里的属性一致。

2.  default-autowire="byType"  按照注入对象的类型,要求:类型只能配置一个实例     

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType">

    <bean id="ud" class="com.gs.xmlauto.User"></bean>
    <bean id="us" class="com.gs.xmlauto.UserService">
        <property name="ud">
                <ref bean="ud"/>
        </property>
    </bean>
    
    <bean id="ut" class="com.gs.xmlauto.UserServlet" autowire="byName">
        <property name="us" ref="utdsdas"></property>
    </bean>
    
    
    <bean id="utdsdas" class="com.gs.xmlauto.UserService">
                <!--     <property name="us" ref="us"></property> -->
    </bean>
</beans>

4. 全注解配置

        第一步：配置让Spring扫描类与支持注解

　　　　<!-- 扫描器-->
　　　　　　<context:component-scan base-package="com.gs.Allxmlauto"/>

　　　　第二步：在类里面加上注解  @Controller @Service @Repository @Component等

 

1.1. 调用名称两套方案：

1.1.1. 方案一：使用@Autowired

@Service

public class UserService {

　　@Autowired

　　@Qualifier("userJdbcDao")

　　private IUserDao userDao;

　　public void save(){

　　userDao.save();

　　}

}

 

1.1.2. 方案二：使用@Resource

@Service

public class UserService {

　　@Resource(name="userJpaDao")

　　private IUserDao userDao;

　　public void save(){

　　userDao.save();

　　}

}

12.Spring 框架中都用到了哪些设计模式？

（1）工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；

（2）单例模式：Bean默认为单例模式。

（3）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；

（4）模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。

（5）观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现--ApplicationListener。

13. spring整合junit测试(spring创建容器)

14. AspectJ和Spring与AOP的关系。

AOP面向切面编程是一种编程思想，是对OOP面向对象编程的一种补充。Spring框架实现了AOP编程思想。而AspectJ框架也实现了AOP的功能，且其实现方式更为简捷，且还支持注解式开发。

所以，Spring又将AspectJ的对于AOP的实现也引入到了自己的框架中。后面使用AOP编程都是在Spring环境下使用AspectJ来进行的。

15.  Spring的AOP理解

AOP（面向切面编程）作为OOP（面向对象编程）的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于事务管理，日志管理，性能监测。

AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

16. 谈谈静态代理和 动态代理

静态代理：就是在程序运行前就已经存在代理类的字节码文件，代理类和原始类的关系在运行前就已经确定。

　　　　（缺点：如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。 ）

动态代理:动态代理类的源码是在程序运行期间通过JVM反射等机制动态生成，代理类和委托类的关系是运行时才确定的。

Spring使用两种方式来完成动态代理：

如果代理的类有接口，使用JDK的动态代理，如果代理的类没有接口，使用CGLIB的动态代理。

演示：JDK的动态代理

UserDao.java

package com.gs.spring.demo1;

public interface UserDao {
    void save();
    void delete();
    void find();
    void update();
}

UserDaoImpl.java

package com.gs.spring.demo1;

public class UserDaoImpl implements UserDao{

    @Override
    public void save() {
        System.out.println("保存用户");
        
    }

    @Override
    public void delete() {
        System.out.println("删除用户");
        
    }

    @Override
    public void find() {
        System.out.println("查找用户");
        
    }

    @Override
    public void update() {
        System.out.println("更新用户");
    }

}

MyJDKProxy.java （代理类重点代码，要记）

package com.gs.spring.demo1;

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

public class MyJDKProxy implements InvocationHandler {
    //将被增强的对象传递到代理中
    private UserDao ud;
    public MyJDKProxy(UserDao ud) {
        this.ud=ud;
    }
    
    // 编写工具方法：生成代理：    
    public UserDao createProxy() {
        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    
        //(ClassLoader loader)第一个参数 指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  
        //(Class<?>[] interfaces)第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  
        //(InvocationHandler h)第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  
        //根据传入的目标返回一个代理对象 
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), 
                ud.getClass().getInterfaces(), this );
        return userDaoProxy;
    }
/*invoke(Object proxy, Method method, Object[] args)
 * 三个参数：代理对象，正在执行的方法，方法的参数*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        if("save".equals(method.getName())){
            System.out.println("权限校验================");
            }
        return method.invoke(ud, args);
    }
}

SpringDemo1Test.java

@Test
    public void Demo1() {
        UserDao ud = new UserDaoImpl();
        UserDao proxy = new MyJDKProxy(ud).createProxy();
        proxy.save();
        proxy.delete();
        proxy.find();
        proxy.update();
    }

演示：CGLIB的动态代理

UserDaoImpl.java

package com.gs.spring.demo2;

public class UserDaoImpl {
    
    public void save() {
        System.out.println("保存用户");
        
    }
    
    public void delete() {
        System.out.println("删除用户");
        
    }
    
    public void find() {
        System.out.println("查找用户");
        
    }

    public void update() {
        System.out.println("更新用户");
    }

}

MyCglibProxy.java（代理类重点代码，要记）

package com.gs.spring.demo2;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class MyCglibProxy implements MethodInterceptor{
    //将被增强的对象传递到代理中
    private UserDaoImpl ud;
    public MyCglibProxy(UserDaoImpl ud) {
        this.ud=ud;
    }
    
    // 生成代理的方法:
    public UserDaoImpl createProxy() {
        // 创建 Cglib 的核心类:
        Enhancer enhancer = new Enhancer();
        // 设置父类:
        enhancer.setSuperclass(ud.getClass());
        // 设置回调:(类似于InvocationHandler对象)
        enhancer.setCallback(this);
        // 生成代理：
        UserDaoImpl proxy = (UserDaoImpl) enhancer.create();
        return proxy;
    }

    /*MethodProxy参数表示：  方法的代理*/
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        if("delete".equals(method.getName())) {
            Object obj = methodProxy.invokeSuper(proxy, args);
            System.out.println("日志记录================");
            return obj;
        }
        //相当于子类调用父类的方法
        return methodProxy.invokeSuper(proxy, args);    
    }
}

SpringDemo2Test.java

@Test
    public void Demo1() {
        UserDaoImpl ud = new UserDaoImpl();
        UserDaoImpl proxy = new MyCglibProxy(ud).createProxy();
        proxy.save();
        proxy.delete();
        proxy.find();
        proxy.update();
    }

17.spring中AOP名词解释

Joinpoint（连接点）：目标对象中，所有可以增强的方法.   Spring只支持方法的连接点。

Pointcut（切点）：目标对象中，已经增强的方法。

Advice（通知/增强）：增强的代码

Target（目标对象）：被代理的对象。

Introduction(引介)：类层面的增强，为类添加一些属性和方法。

Weaving（织入）：将通知应用到切入点的过程

Proxy（代理）：将通知织入目标对象之后，形成代理对象。

Aspect（切面）：由切点和增强组成。在SpringAOP中，切面通过带有@Aspect注解的类实现。

 

 18. Spring通知有哪些类型？

1. 前置通知 ：在目标方法执行之前执行.
2. 后置通知 ：在目标方法执行之后执行
3. 异常通知：在目标方法执行出现 异常的时候 执行
4. 最终通知 ：无论目标方法是否出现异常 最终通知都会 执行，类似于Java中的finally块。

5. 环绕通知 ：环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。环绕通知还需要负责决定是继续处理join point(调用ProceedingJoinPoint的proceed方法)还是中断执行。

五种通知的执行顺序为： 前置通知→环绕通知→正常返回通知/异常返回通知→后置通知。

 

Xml版实现AOP

<aop:config>
　　<!-- 切点 -->
    <aop:pointcut expression="execution(* cn.itsource.aop.I*Service.*(..))" id="pointcut" />
　　<!-- 切面 ：一个切点  对应多个增强（通知） -->
    <aop:aspect  ref="txManager">
        <!-- 前置通知 -->
        <aop:before method="begin" pointcut-ref="pointcut"/>
        <!-- 后置通知 -->
        <aop:after-returning method="commit" pointcut-ref="pointcut"/>
        <!-- 异常通知 -->
        <aop:after-throwing method="rollback" pointcut-ref="pointcut"/>
        <!-- 最终通知 -->
        <aop:after method="close" pointcut-ref="pointcut" />
    </aop:aspect>
</aop:config>

<!-- 
    环绕通知：有了环绕,就不需要用另外几个通知(会重复)
               如果有两个以上的通知，建议使用环绕
 -->
<aop:around method="around" pointcut-ref="pointcut" />

注解版实现AOP

配置文件

<!-- 组件搜索 -->

<context:component-scan base-package="com.gs" />

<!-- 支持aop注解 -->

<aop:aspectj-autoproxy />

事务管理器

@Component
@Aspect //AOP的类注解
public class TxManager {
    //设置切点
    @Pointcut("execution(* cn.itsource.aopanno.I*Service.*(..))")
    public void pointcut(){}
    //前置通知
    @Before("pointcut()")
    public void begin(){
        System.out.println("开启事务....");
    }
    //后置通知
    @AfterReturning("pointcut()")
    public void commit(){
        System.out.println("提交事务...");
    }
    //异常通知
    @AfterThrowing(pointcut="pointcut()",throwing="e")
    public void rollback(Throwable e){
        System.out.println("回滚事务....");
        System.out.println(e.getMessage());
    }
    //最终通知
    @After("pointcut()")
    public void close(){
        System.out.println("关闭资源....");
    }
}

环绕通知方法：

//温馨提醒：如果要使用环绕通知的话，把其它几个通知的注解去掉(不然会出现重复)
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint){
    Object object = null;
    try {
        begin();
        object = joinPoint.proceed(); //执行相应的代码
        commit();
    } catch (Throwable e) {
        rollback(e);
    }finally{
        close();
    }
    return object;
}

参考文献: https://www.cnblogs.com/V1haoge/p/6106456.html

　　　　https://blog.csdn.net/itcats_cn/article/details/81479185

　　　　https://blog.csdn.net/a745233700/article/details/80959716

　　　　https://blog.csdn.net/lz1170063911/article/details/79772474

　　　　https://www.cnblogs.com/xiaoxi/p/5865330.html

　　　　https://blog.csdn.net/yhl_jxy/article/details/78792414