重学Spring总结

1、Spring框架的诞生

1、BeanFactory 快速入门

1.1、BeanFactory完成了loC思想的实现：

1)导入Spring相关的依赖：

<dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.3.6version>
        dependency>
    dependencies>

2)定义Uservice接口及其UserviceImpl实现类；

3)创建Bean的配置资源文件，文件名最好为：applicationContext.xml(规范)，将UserServicelmpl的信息配置到该xml中

<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="userService" class="cn.js.service.impl.UserServiceImpl">bean>
beans>

4)编写测试代码，创建BeanFactory，加载配置文件，获取UserService实例对象

1、通过工厂对象进行创建：

//1.创建工厂对象
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

//2.创建一个读取器，用于读取Bean 的资源文件(.xml文件)
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

//3、读取配置文件给工厂
reader.loadBeanDefinitions("applicationContext.xml");

//4、根据ID获取Bean实例对象
UserService userService = (UserService)beanFactory.getBean("userService");
System.out.println(userService);

2、直接从classpatch 路径去寻找配置文件创建资源对象(该方式已废弃了解即可)

//1、从ClassPath路径去寻找配置文件创建资源对象
Resource resource = new ClassPathResource("applicationContext.xml");

//2、根据资源对象创建Bean工厂对象
BeanFactory beanFactory = new XmlBeanFactory(resource);

//3、从SpringIoc容器中获取指定名称的对象
UserService userService = (UserService)beanFactory.getBean("userService");
System.out.println(userService);

上面使用BeanFactory完成了loC思想的实现，下面去实现以下DI依赖注入(setter方式):

1.2、使用BeanFactory通过setter方式去实现以下DI依赖注入：

1)定义UserDao接口及其UserDaolmpl实现类

public interface UserDao {}
public class UserDaoImpl implements UserDao {}

2)修改UserServicelmpl代码，添加一个setUserDao(UserDao userDao)用于接收注入的对象:

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        System.out.println("BeanFactory工厂调用该方法--》"+userDao);
        this.userDao=userDao;
    }
}

3)修改applicationContext.xml配置文件，定义UserService的中嵌入配置注入UserDao;

<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="userService" class="cn.js.service.impl.UserServiceImpl">
        <property name="userDao" ref="UserDao">property>
    bean>
    
    <bean id="UserDao" class="cn.js.dao.impl.UserDaoImpl">bean>
beans>

4)修改测试代码，获得UserService时，setUserService方法执行了注入操作。

  		//1.创建工厂对象
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        //2.创建一个读取器，用于读取Bean 的资源文件(.xml文件)
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

        //3、读取配置文件给工厂
        reader.loadBeanDefinitions("applicationContext.xml");

        //4、根据ID获取Bean实例对象
        UserService userService = (UserService)beanFactory.getBean("userService");
        System.out.println(userService);

        UserDao userdao = (UserDao)beanFactory.getBean("UserDao");
        System.out.println(userdao);

打个断点：此时userDao，已经被注入

2、ApplicationContext 快速入门（重要）

ApplicationContext 称为Spring容器，内部封装了BeanFactory，比BeanFactory功能更丰富更强大，使用ApplicationContext 进行开发时，xml配置文件的名称习惯写成applicationContext.xml;

2.1、ApplicationContext实现Ioc思想

1）前三步和BeanFactry相同

5）读取核心配置文件获取实例化容器对象

//创建ApplicationContext，加载配置文件，实例化容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//根据beanName获得容器中的Bean实例
UserService userService = (UserService) applicationContext.getBean("userService");
System.out.println(userService);

3、BeanFactory与ApplicationContext的关系:

1、 BeanFactory是Spring的早期接口，称为`Spring的Bean工厂`，ApplicationContext是后期更高级接口，称之为`Spring 容器`;  
2、 ApplicationContext在BeanFactory基础上对功能进行了扩展，例如: 监听功能、国际化功能等。BeanFactory的API更偏向底层，ApplicationContext的API大多数是对这些底层API的封装;
3、 Bean创建的主要逻辑和功能都被封装在BeanFactory中，ApplicationContext不仅继承了BeanFactory，而目ApplicationContext内部还维护着BeanFactorv的引用，所以，ApplicationContext与BeanFactorv既有继承关系，又有融合关系。
4、 Bean的初始化时机不同，原始BeanFactory是在首次调用getBean时才进行Bean的创建，而ApplicationContext则是配置文件加载，容器一创建就将Bean都实例化并初始化好

ApplicationContext除了继承了BeanFactory外，还继承了ApplicationEventPublisher (事件发布器)、ResouresPatternResolver (资源解析器)、MessageSource (消息资源)等。

但是ApplicationContext的核心功能还是BeanFactory。

4、BeanFactory的继承体系

BeanFactory的继承体系

BeanFactory是核心接口，项目运行过程中肯定有具体实现参与，这个具体实现就是DefaultListableBeanFactory而ApplicationContext内部维护的Beanfactory的实现类也是它

5、ApplicationContext的继承体系

1.ApplicationContext的继承体系

只在Spring基础环境下，即只导入spring-context坐标时，此时ApplicationContext的继承体系

2.只在Spring基础环境下，常用的三个ApplicationContext作用如下:

3.在Spring的web环境下，常用的两个ApplicationContext作用如下

2、基于XML的Spring应用

2.1、SpringBean的配置详解

Spring开发中主要是对Bean的配置，Bean的常用配置一览如下：

1）Bean的基础配置

例如:配置UserDaolmpl由Spring容器负责管理

<bean id="userDao" class="com.js.dao .impl.UserDaoImpl"/>

此时存储到Spring容器(singleObjects单例池) 中的Bean的beanName是userDao，值是UserDaolmpl对象，可以根据beanName获取Bean实例

applicationContext.getBean("userDao");//beanName:进入Spring容器将 bean id="userDao" 这个ID转换成beanname

如果不配置id，则Spring会把当前Bean实例的全限定名作为beanName

applicationContext.getBean("com.js.dao.impl.UserDaoImpl") ;

2) Bean的别名配置

可以为当前Bean指定多个别名，根据别名也可以获得Bean对象

<bean id="userDao" "uname="aaa,bbb" class="com.js.dao.impl.UserDaoImpl"/>

此时多个名称都可以获得UserDaolmpl实例对象

applicationContext.getBean("userDao");
applicationContext.getBean("aaa");
applicationContext.getBean("bbb");

3) Bean的范围配置

默认情况下，单纯的Spring环境Bean的作用范围有两个: Singleton和Prototype

• singleton: 单例，默认值，Spring容器创建的时候，就会进行Bean的实例化，并存储到容器内部的单例池中每次getBean时都是从单例池中获取相同的Bean实例;

• prototype: 原型，Spring容器初始化时不会创建Bean实例，当调用getBean时才会实例化Bean，每次getBean都会创建一个新的Bean实例。

4) Bean的延迟加载

当lazy-init设置为true时为延迟加载，也就是当Spring容器创建的时候，不会立即创建Bean实例，等待用到时再创建Bean实例并存储到单例池中去，后续在使用该Bean直接从单例池获取即可，本质上该Bean还是单例的

< bean id="userDao"  class="com.js.dao.impl.UserDaoImpl"  ulazy-init="true"/>

5）Bean的初始化和销毁方法配置

Bean在被实例化后，可以执行指定的初始化方法完成一些初始化的操作，Bean在销毁之前也可以执行指定的销毁方法完成一些操作，初始化方法名称和销毁方法名称通过

< bean id="userDao"class="com.js.dao.impl.UserDaoImpln" init-method="init"  destroy-method="destroy" />

public class UserDaoImpl implements UserDao {
	public UserDaoImpl(){System.out.println("UserDaoImpl创建了...");}
    public void init(){System.out.printn("初始化方法...");}
    public void destroy(){ System.out.println("销毁方法...");}
}

public static void main(String[] args){
	ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext();
    UserService userService = (UserService) applicationContext.getBean("userDao")
    System.out.printIn(userService);//--------->这个地方是不会调用销毁方法的，如果没有调用close方法，Spring在执行这句输出语句后，就已经销毁了，还没有来得及调用销毁方法，所以我们要显示的关闭容器
    applicationContext.close() ;//关闭容器
} 

扩展: 除此之外，我们还可以通过实现 lnitializingean 接口，完成一些Bean的初始化操作，如下

public class UserDaoImpl implements UserDao, InitializingBean {
    public UserDaoImpl() {System.out.println("userDaoImpl创建了...");}
    public void init(){System.out.println("初始化方法...");}
    public void destroy(){System.out.println("销毁方法...");}
    //执行时机早于init-method配置的方法
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean...");
    }
}

6）Bean的实例化配置

Bean的实例化配置:就是Spring 帮我们创建Bean

Spring的实例化方式主要如下两种：

• 构造方式实例化: 底层通过构造方法对Bean进行实例化；

  • 1.1 使用空构造器
  • 1.2 使用有参构造器

• 工厂方式实例化: 底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化:

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化，Spring中配置的几乎都是无参构造该方式，此处不在述。下面讲解有参构造方法实例化Bean

//有参构造方法
public UserDaoImpl(String name){}

有参构造在实例化Bean时，需要参数的注入，通过标签，嵌入在标签内部提供构造参数，如下:

<bean id="userDao" class="com,js,dao implUserDaoImpl">
    <constructor-arg name="name" value="haohao"/>
bean>

工厂方式实例化:

工厂方式实例化Bean，又分为如下三种:

• 静态工厂方法实例化Bean

• 实例工厂方法实例化Bean

• 实现FactoryBean规范延迟实例化Bean

1) 、静态工厂方法实例化Bean

静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其 静态方法配置给Spring即可

//工厂类
public class UserDaoFactoryBean {
//非静态工厂方法
public static UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();
 }
}

<bean id="userDao" class="com.js.factory.UserDaoFactoryBean" factorymethod="getUserDao">
<constructor-arg name="name" value="haohao"/>
bean>

解释：

1.Spring容器看到factorymethod：时知道，不是将"com.js.factory.UserDaoFactoryBean"变成对象而是将内部的getUserDao方法的返回值，当成对象，将我们指定的id="userDao"
作为BeanName，存储到容器当中;

2.<constructor-arg>标签不仅仅是为构造方法传递参数，只要是为了实例化对象而传递的参数都可以通过<constructor-arg>标签完成，例如上面通过静态工厂方法实例化Bean所传递的参数也是要通过<constructor-arg>进行传递的

测试代码，直接通过ApplicationContext获得userDao即可:

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

断点调试，UserDaoImpl实例对象会存在于单例池中：

作用：

1.引入一些第三方的jar包，交给Spring管理时；
2.创建摸个对象之前有一些其他操作；

2)、实例工厂方法：

​ 实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂 对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean；

//工厂类
public class UserDaoFactoryBean2 {
//非静态工厂方法
public UserDao getUserDao(String name){
//可以在此编写一些其他逻辑代码
return new UserDaoImpl();
}
}

​ 实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂 对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean；

<bean id="userDaoFactoryBean2" class="com.js.factory.UserDaoFactoryBean2"/>

<bean id="userDao" factory-bean="userDaoFactoryBean2" factory-method="getUserDao">
<constructor-arg name="name" value="haohao"/>
bean>

解释

"factory-bean":告诉Spring 容器，实例工厂对象是哪个
"factory-method":告诉Spring 容器，实例工厂对象中的方法是哪个

测试代码，直接通过ApplicationContext获得userDao即可:

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

通过断点观察单例池singletonObjects，发现单例池中既有工厂Bean实例，也有目标Bean实例，且都是在Spring 容器创建时，就完成了Bean的实例化；

3）、Bean的实例化配置：

上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范， FactoryBean接口定义如下：

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = “factoryBeanObjectType”;
    T getObject() throws Exception; //获得实例对象方法
    Class<?> getObjectType(); //获得实例对象类型方法

    default boolean isSingleton() {
		return true;
	}
}

1、定义工厂实现FactoryBean:

public class UserDaoFactoryBean3 implements FactoryBean<UserDao> {
    
    //返回Bean是谁
    public UserDao getObject() throws Exception {
    	return new UserDaoImpl();
    }
    
    //返回bean的类型是啥
	public Class<?> getObjectType() {
		return UserDao.class;
	}
}

2、配置FactoryBean交由Spring管理即可

<bean id="userDao" class="com.js.factory.UserDaoFactoryBean3"/>

3、 通过Spring容器根据beanName可以正常获得UserDaoImp

ApplicationContext applicationContext = new ClassPathxmlApplicationContext("applicationContext.xml");
Object userDao = applicationContext.getBean("userDao");
System.out.println(userDao);

通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中，但是 getObject() 方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject() ， 此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池 中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例。

7）Bean的依赖注入配置

Bean的依赖注入有两种方式：

​ 其中，ref 是 reference 的缩写形式，翻译为：涉及，参考的意思，用于引用其他Bean的id。value 用于注入普通 属性值。

依赖注入的数据类型有如下三种：

​ ⚫ 普通数据类型，例如：String、int、boolean等，通过value属性指定。

​ ⚫ 引用数据类型，例如：UserDaoImpl、DataSource等，通过 ref 属性指定。

​ ⚫ 集合数据类型，例如：List、Map、Properties等。

一、通过Seet方法进行注入

1）对于list注入：

1. 注入 List 集合 – 普通数据

<property name="strList">
    <list>
        <value>haohaovalue>
        <value>miaomiaovalue>
    list>
property>

2.注入 List 集合 – 引用数据

<property name="objList">
    <list>
        <bean class="com.js.dao.impl.UserDaoImpl">bean>
        <bean class="com.js.dao.impl.UserDaoImpl">bean>
        <bean class="com.js.dao.impl.UserDaoImpl">bean>
    list>
property>

也可以直接引用容器中存在的Bean

<bean id="userDao" class="com.js.dao.impl.UserDaoImpl"/>
<bean id="userDao2" class="com.js.dao.impl.UserDaoImpl"/>
<bean id="userDao3" class="com.js.dao.impl.UserDaoImpl"/>

<bean id="userService" class="com.js.service.impl.UserServiceImpl">
    <property name="objList">
        <list>
            <ref bean="userDao">ref>
            <ref bean="userDao2">ref>
            <ref bean="userDao3">ref>
        list>
    property>
bean>

5)、注入 Set 集合

//注入泛型为字符串的Set集合
public void setValueSet(Set<String> valueSet){
    valueSet.forEach(str->{
    System.out.println(str);
    });
}

//注入泛型为对象的Set集合
public void setObjSet(Set<UserDao> objSet){
    objSet.forEach(obj->{
    System.out.println(obj);
    });
}

<property name="valueSet">
    <set>
        <value>muzivalue>
        <value>muranvalue>
    set>
property>

<property name="objSet">
    <set>
        <ref bean="userDao">ref>
        <ref bean="userDao2">ref>
        <ref bean="userDao3">ref>
    set>
property>

3）、注入 Map 集合

注入 Map 集合

//注入值为字符串的Map集合
public void setValueMap(Map<String,String> valueMap){
    valueMap.forEach((k,v)->{
    System.out.println(k+"=="+v);
    });
}

//注入值为对象的Map集合
public void setObjMap(Map<String,UserDao> objMap){
    objMap.forEach((k,v)->{
    System.out.println(k+"=="+v);
    });
}

<!--注入值为字符串的Map集合-->
<property name="valueMap">
    <map>
        <entry key="aaa" value="AAA" />
        <entry key="bbb" value="BBB" />
        <entry key="ccc" value="CCC" />
    </map>
</property>

<!--注入值为对象的Map集合-->
<property name="objMap">
    <map>
        <entry key="ud" value-ref="userDao"/>
        <entry key="ud2" value-ref="userDao2"/>
        <entry key="ud3" value-ref="userDao3"/>
    </map>
</property>

4)、注入 Properties 键值对

//注入Properties
public void setProperties(Properties properties){
    properties.forEach((k,v)->{
    	System.out.println(k+"=="+v);
    });
}
	

<property name="properties">
    <props>
        <prop key="xxx">XXXprop>
        <prop key="yyy">YYYprop>
    props>

<bean id="userService" class="com.js.service.impl.UserServiceImpl"
autowire="byType">

//根据beanName获取容器中的Bean实例，需要手动强转
UserService userService = (UserService) applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例，如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例，指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService",
UserService.class);

<bean class="com.alibaba.druid.pool.DruidDataSource">

<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
bean>

<bean id="" name="" class="" scope="" lazy-init="" init-method="" destroy-method=""
abstract="" autowire="" factory-bean="" factory-method="">bean>

//获取方式：applicationContext.getBean("userDao");
@Component("userDao")//表示将当前这个Bean创建好的实例对象以指定的名称"userDao" BeanName存储到Spring容器当中
public class UserDaoImpl implements UserDao {
}
//获取方式：applicationContext.getBean("userDaoImpl");
@Component
public class UserDaoImpl implements UserDao {
}

<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.xsd">

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

<bean id="" name="" class="" scope="" lazy-init="" init-method="" destroy-method=""
abstract="" autowire="" factory-bean="" factory-method="">bean>

@Component("userDao")
@Scope("singleton")
@Lazy(true)
public class UserDaoImpl implements UserDao{
    @PostConstruct
    public void init(){
        sout("初始方法");
    }
    @PreDestroy
    public void destroy(){
        sout("销毁方法")
    }
}

@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Service("userService")
public class UserServiceImpl implements UserService{}
@Controller("userService")
public class UserController {}

<bean id="" class="">
<property name="" value=""/>
<property name="" ref=""/>
bean>

@Value("haohao")
private String username;
@Value("haohao")
public void setUsername(String username){
System.out.println(username);
}

@Value("${jdbc.username}")
private String username;
@Value("${jdbc.username}")
public void setUsername(String username){
System.out.println(username);
}

<context:property-placeholder location="classpath:jdbc.properties"/>

//1、使用在属性上直接注入：
@Autowired
private UserDao userDao;


//2、使用在方法上直接注入，他是根据参数类型进行匹配的，方法名可以不是set方法开头的，
@Autowired
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

//匹配当前Bean
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}

@Autowired
@Qualifier("userDao2")
private UserDao userDao;
@Autowired
@Qualifier("userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

@Resource
private UserDao userDao;
@Resource(name = "userDao2")
public void setUserDao(UserDao userDao){
System.out.println(userDao);
}

//将方法返回值Bean实例以@Bean注解指定的名称存储到Spring容器中
@Bean("dataSource")//参数就是BeanName，没有加，以方法名设置为BeanName
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    return dataSource;
}

@Bean
@Autowired //根据类型匹配参数
public Object objectDemo01(UserDao userDao){
    System.out.println(userDao);
    return new Object();
}

@Bean
public Object objectDemo02(@Qualifier("userDao") UserDao userDao,@Value("${jdbc.username}") String username){
    System.out.println(userDao);
    System.out.println(username);
    return new Object();
}

<context:property-placeholder location="classpath:jdbc.properties"/>

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

<import resource="classpath:beans.xml"/>

@Configuration
public class ApplicationContextConfig {}

@Configuration
@ComponentScan({"com.js.service","com.js.dao"})
public class ApplicationContextConfig {}

@Configuration
@ComponentScan
@PropertySource({"classpath:jdbc.properties","classpath:xxx.properties"})
public class ApplicationContextConfig {}

@Configuration
@ComponentScan
@PropertySource("classpath:jdbc.properties")
@Import(OtherConfig.class)
public class ApplicationContextConfig {}

//自定义增强类
public class MyAdvice {
public void beforeAdvice(){
System.out.println("beforeAdvice ...");
}
public void afterAdvice(){
System.out.println("afterAdvice ...");
}
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContextAware;

public class MockAopBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
    private ApplicationContext applicationContext;//注入Spring容器对象

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        MyAdvice myAdvice = applicationContext.getBean(MyAdvice.class);//获得Advice对象
        String packageName = bean.getClass().getPackage().getName();
        if ("com.js.service.impl".equals(packageName)) {
//对Bean进行动态代理，返回的是Proxy代理对象
            Object proxyBean = Proxy.newProxyInstance(
                    bean.getClass().getClassLoader(),
                    bean.getClass().getInterfaces(),
                    (Object proxy, Method method, Object[] args) -> {
                        myAdvice.beforeAdvice();//执行Advice的before方法
                        Object result = method.invoke(bean, args);//执行目标
                        myAdvice.afterAdvice();//执行Advice的after方法
                        return result;
                    });
//返回代理对象
            return proxyBean;
        }
        return bean;
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.6version>
dependency>

<bean id="userService" class="com.js.service.impl.UserServiceImpl"/>

<aop:config>

<aop:pointcut id="myPointcut" expression="execution(void
com.js.service.impl.UserServiceImpl.show1())"/>

<aop:aspect ref="myAdvice">

<aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>

<aop:after-returning method="afterAdvice" pointcut-ref="myPointcut"/>
aop:aspect>