Spring基础系列（二）

秒速五厘米 2021-09-27 00:42 326阅读 0赞

# 一、使用注解配置Spring #

配置XML文件：

将car对象注入到Spring中：

@Component("car2")
    public class Car { 
        @Value("yellow")
        private String color;
    
        public void setColor(String color) {
            this.color = color;
        }
        @Override
        public String toString() {
            return "Car{" +
                    "color='" + color + '\'' +
                    '}';
        }
    }

将user对象注入到Spring中：

//对象名为user，将其放入Spring容器中
    @Component("user")
    //@Service("user") //service层
    //@Controller("user") //web层
    //@Repository("user") //dao层
    //@Scope(scopeName = "protoType") //指定对象作用范围：多例
    public class User { 
        @Value("long")  //通过反射的Field赋值，破坏了封装性
        private String name;
        //@Autowired //自动装配
        //自动装配问题：如果匹配多个类型一致的对象，将无法选择具体注入哪一个对象
        //@Qualifier("car2") 使用Qualifier注解告诉Spring容器自动装配哪个名称的对象
        //使用Resource注解手动注入，指定注入哪个名称的对象（推荐）
        @Resource(name="car2")
        private Car car;
        @PostConstruct   //在对象被创建后调用
        public void init(){
            System.out.println("我是初始化方法");
        }
        @PreDestroy      //在对象被销毁之前调用
        public void destroy(){
            System.out.println("我是销毁方法");
        }
    
        public Car getCar() {
            return car;
        }
        public void setCar(Car car) {
            this.car = car;
        }
    
        public String getName() {
            return name;
        }
        //@Value("long") //通过set方法赋值（推荐）
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", car=" + car +
                    '}';
        }
    }

测试：

public class Main {
        public static void main(String[] args){
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
            User bean = (User) context.getBean("user");
            System.out.println(bean.toString());
        }
    }

运行结果：  
**我是初始化方法  
User\{name=’long’, car=Car\{color=’yellow’\}\}**

# 二、Spring中的AOP #

Spring能够为容器中管理的对象生成动态代理对象。  
Spring实现Aop的原理：Spring封装了动态代理和cglib代理  
动态代理局限性：被代理对象必须要有接口，才能产生代理对象。  
cglib代理：第三方代理技术，可以对任何类生成代理。代理的原理是对目标对象进行继承代理。如果目标对象被final修饰，那么该类无法被cglib代理。  
**使用动态代理：**  
UserService：

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

UserServiceImpl：

public class UserServiceImpl implements UserService { 
        @Override
        public void save() {
            System.out.println("保存用户!");
            //int i = 1/0;
        }
        @Override
        public void delete() {
            System.out.println("删除用户!");
        }
        @Override
        public void update() {
            System.out.println("更新用户!");
        }
        @Override
        public void find() {
            System.out.println("查找用户!");
        }
    }

生成代理：

public class UserServiceProxyFactory implements InvocationHandler { 
        public UserServiceProxyFactory(UserService us) {
            super();
            this.us = us;
        }
        private UserService us;
        public UserService getUserServiceProxy(){
            //生成动态代理
            UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
                    UserServiceImpl.class.getInterfaces(),  //被代理对象实现的接口
                    this);
            //返回
            return usProxy;
        }
        @Override
        public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {
            System.out.println("打开事务!");
            Object invoke = method.invoke(us, arg2);
            System.out.println("提交事务!");
            return invoke;
        }
    }

测试：

public class Demo {
        @Test
        //动态代理
        public void fun1(){
            UserService us = new UserServiceImpl();
            //传入代理对象
            UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
            UserService usProxy = factory.getUserServiceProxy();
            usProxy.save();
            //代理对象与被代理对象实现了相同的接口
            //代理对象 与 被代理对象没有继承关系
            System.out.println(usProxy instanceof UserServiceImpl );//false
        }
    }

运行结果：  
**打开事务!  
保存用户!  
提交事务!  
false**  
关于动态代理部分，可以看这篇博客[JavaWeb基础系列（十三）类加载器、动态代理][JavaWeb]  
**使用cglib代理：**

public class UserServiceProxyFactory2 implements MethodInterceptor { 
        public UserService getUserServiceProxy(){
            //帮我们生成代理对象
            Enhancer en = new Enhancer();
            //设置对谁进行代理
            en.setSuperclass(UserServiceImpl.class);
            //代理要做什么
            en.setCallback(this);
            //创建代理对象
            UserService us = (UserService) en.create();
            return us;
        }
        @Override
        public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
            //打开事务
            System.out.println("打开事务!");
            //调用原有方法
            Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
            //提交事务
            System.out.println("提交事务!");
            return returnValue;
        }
    }

**代码测试：**

@Test
        public void fun2(){
            UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
            UserService usProxy = factory.getUserServiceProxy();
            usProxy.save();
            //判断代理对象是否属于被代理对象类型
            //代理对象继承了被代理对象=>true
            System.out.println(usProxy instanceof UserServiceImpl );  //true
        }

**运行结果：  
打开事务!  
保存用户!  
提交事务!  
true**

## 2.1、Spring中的AOP名词解释 ##

JoinPoint（连接点）：目标对象中所有可以增强的方法。  
PointCut（切入点）：目标对象，已经增强的方法。  
Advice（通知 / 增强）：增强的代码。  
Target（目标对象）：被代理对象。  
Weaving（织入）：将通知应用到切入点的过程。  
Proxy（代理）：将通知织入到目标对象之后形成代理对象。  
Aspect（切面）：切入点+通知

## 2.2、Spring中的AOP演示 ##

创建通知类：

//表示该类是一个通知类
    public class MyAdvice {
        //前置通知
        public void before(){
            System.out.println("这是前置通知!!");
        }
        //后置通知
        public void afterReturning(){
            System.out.println("这是后置通知(如果出现异常不会调用)!!");
        }
        //环绕通知
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("这是环绕通知之前的部分!!");
            Object proceed = pjp.proceed();//调用目标方法
            System.out.println("这是环绕通知之后的部分!!");
            return proceed;
        }
        //异常通知
        public void afterException(){
            System.out.println("出事啦!出现异常了!!");
        }
        //后置通知
        public void after(){
            System.out.println("这是后置通知(出现异常也会调用)!!");
        }
    }

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:context="http://www.springframework.org/schema/context" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <context:component-scan base-package="domain"></context:component-scan>
        <context:component-scan base-package="aop"></context:component-scan>
        
        <bean name="userServiceTarget" class="aop.service.UserServiceImpl"></bean>
        
        <bean name="myAdvice" class="aop.advice.MyAdvice"></bean>
        
        <aop:config>
            
            <aop:pointcut id="pc" expression="execution(* aop.service.UserServiceImpl.*(..))"></aop:pointcut>
            <aop:aspect ref="myAdvice" >
                
                <aop:before method="before" pointcut-ref="pc"></aop:before>
                
                <aop:after-returning method="afterReturning" pointcut-ref="pc"></aop:after-returning>
                
                <aop:around method="around" pointcut-ref="pc" />
                
                <aop:after-throwing method="afterException" pointcut-ref="pc"></aop:after-throwing>
                
                <aop:after method="after" pointcut-ref="pc"></aop:after>
            </aop:aspect>
        </aop:config>
    </beans>

测试：

package aop;
    
    import aop.service.UserService;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import javax.annotation.Resource;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:/spring-config.xml")
    public class Demo { 
        @Resource(name="userServiceTarget")
        private UserService us;
    
        @Test
        public void fun1(){
            us.save();
        }
    }

运行结果：  
**我是初始化方法这是前置通知!!  
这是环绕通知之前的部分!!  
保存用户!  
这是后置通知(出现异常也会调用)!!  
这是环绕通知之后的部分!!  
这是后置通知(如果出现异常不会调用)!!  
我是销毁方法**

## 2.3、Spring中的AOP注解方式演示 ##

XML文件：

通知：

package aop.advice;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    
    //通知类
    @Aspect
    //表示该类是一个通知类
    public class MyAdvice2 { 
        @Pointcut("execution(* aop.service.UserServiceImpl.*(..))")
        public void pc(){}
        //前置通知
        //指定该方法是前置通知,并制定切入点
        @Before("MyAdvice2.pc()")
        public void before(){
            System.out.println("这是前置通知!!");
        }
        //后置通知
        @AfterReturning("execution(* aop.service.UserServiceImpl.*(..))")
        public void afterReturning(){
            System.out.println("这是后置通知(如果出现异常不会调用)!!");
        }
        //环绕通知
        @Around("execution(* aop.service.UserServiceImpl.*(..))")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("这是环绕通知之前的部分!!");
            Object proceed = pjp.proceed();//调用目标方法
            System.out.println("这是环绕通知之后的部分!!");
            return proceed;
        }
        //异常通知
        @AfterThrowing("execution(* aop.service.UserServiceImpl.*(..))")
        public void afterException(){
            System.out.println("出事啦!出现异常了!!");
        }
        //后置通知
        @After("execution(* aop.service.UserServiceImpl.*(..))")
        public void after(){
            System.out.println("这是后置通知(出现异常也会调用)!!");
        }
    }

测试：

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:/aop/advice/spring-config.xml")
    public class Demo { 
        @Resource(name="userServiceTarget")
        private UserService us;
        @Test
        public void fun1(){
            us.save();
        }
    }

运行结果：  
**这是环绕通知之前的部分!!  
这是前置通知!!  
保存用户!  
这是环绕通知之后的部分!!  
这是后置通知(出现异常也会调用)!!  
这是后置通知(如果出现异常不会调用)!!**

--------------------

**Spring系列目录：  
[Spring基础系列（一）][Spring]  
[Spring基础系列（二）][Spring 1]  
[Spring基础系列（三）][Spring 2]**

> **转载请标明出处，原文地址：[https://blog.csdn.net/weixin\_41835916][https_blog.csdn.net_weixin_41835916]  
> 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。  
> ![这里写图片描述][70]**

[JavaWeb]: https://blog.csdn.net/weixin_41835916/article/details/80869293
[Spring]: https://blog.csdn.net/weixin_41835916/article/details/80852760
[Spring 1]: https://blog.csdn.net/weixin_41835916/article/details/80872595
[Spring 2]: https://blog.csdn.net/weixin_41835916/article/details/80877562
[https_blog.csdn.net_weixin_41835916]: https://blog.csdn.net/weixin_41835916
[70]: /images/20210923/f96a0d357356425b8404f40eeec861a3.png