spring 纯注解方式与AOP

spring注解方式

以前我也使用过纯注解方式.现在在这里做个记录

　我们先认识几个我们都耳熟能详的注解

　@configuration :从spring3.0这个注解就可以用于定义配置类,可以替换xml配置文件,相当于beans的根标签,配置类中可以包含一个或者多个@bean注解这些方法都会被一个
AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。
@bean: 相当于 bean
@componentScan
@PropertySource 相当于context:property-placeholder标签如果是在类路径下,需要加上classpath 和@value 配合使用

/**
 * 相当于一个beans
 */
@Configuration
@ComponentScan(basePackages = "xiaodao.spring")
public class SpringConfiguration {

    public SpringConfiguration() {
        System.out.println("spring 容器启动");
    }

    /**
     * bean id 默认是bean的方法名
     * @return
     */

 /*   @Bean
    public UserService userService(){
        return new UserServiceImpl();
    }*/
}

public class SpringConfigurationTest {

    @Test
    public void test1(){
        //创建纯注解方式的spring 容器
        ApplicationContext applicationContext  = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = (UserService) applicationContext.getBean("userService");
       userService.save();
    }

}

spring 分模块开发

@import 注解的使用方法　　

我们在spring中有各种各样的配置文件.写在一个类中,肯定是不合适的.我们需要分门分类

@Configuration
@ComponentScan(basePackages = "com.kkb.spring")
@Import({ JdbcConfig.class})
public class SpringConfiguration {
}


@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
    }

什么是AOP呢?

　　AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

　　AOP最早是AOP联盟的组织提出的,指定的一套规范,spring将AOP的思想引入框架之中,通过预编译方式和运行期间动态代理实现程序的统一维护的一种技术,

　　预编译方式在spring中没有使用,因为要结合其他编译方式,和spring造成强耦合,预编译方式就是在程序没有运行前编译.

　　AOP是OOP的延续,,AOP解决的是从横向解决代码重复的问题 ,OOP是从纵向解决代码的重复问题

　　AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）讲业务逻辑和系统处理的代码进行解耦如如:关闭连接事物管理,操作日志的记录

AOP 的相关术语?

1. Joinpoint(连接点) -- 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点

2. Pointcut(切入点) -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义

3. Advice(通知/增强) -- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

4. Introduction(引介) -- 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field

5. Target(目标对象) -- 代理的目标对象

6. Weaving(织入) -- 是指把增强应用到目标对象来创建新的代理对象的过程

7.Proxy（代理） -- 一个类被AOP织入增强后，就产生一个结果代理类

8. Aspect(切面) -- 是切入点和通知的结合，以后咱们自己来编写和配置的

AOP实现之AspectJ（了解）

***AspectJ是一个java实现的AOP框架，它能够对java代码进行AOP编译（一般在编译期进行），让java代码具有AspectJ的AOP功能（当然需要特殊的编译器）

***可以这样说AspectJ是目前实现AOP框架中最成熟，功能最丰富的语言，更幸运的是，AspectJ与java程序完全兼容，几乎是无缝关联，因此对于有java编程基础的工程师，上手和使用都非常容易。

***了解AspectJ应用到java代码的过程（这个过程称为织入），对于织入这个概念，可以简单理解为aspect(切面)应用到目标函数(类)的过程。

***对于这个过程，一般分为动态织入和静态织入，动态织入的方式是在运行时动态将要增强的代码织入到目标类中，这样往往是通过动态代理技术完成的，如Java JDK的动态代理(Proxy，底层通过反射实现)或者CGLIB的动态代理(底层通过继承实现)，Spring AOP采用的就是基于运行时增强的代理技术

***ApectJ采用的就是静态织入的方式。ApectJ主要采用的是编译期织入，在这个期间使用AspectJ的acj编译器(类似javac)把aspect类编译成class字节码后，在java目标类编译时织入，即先编译aspect类再编译目标类。

spring 纯注解方式与AOP

Spring AOP实现原理分析

　　spring AOP 是通过动态代理技术实现的

　　而动态代理的技术是通过反射来实现的

　　动态代理技术的实现方式有两种：基于接口的JDK动态代理和基于继承的CGLib动态代理。

我们来写一下 jdk的代理和cglib的代理类

　　我们要代理的对象

public interface UserService {

    public void save();
}
@Service("userService")
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("userserviceimpl  save方法");
    }
}

代理的实现

public class MyProxyUtils {

    /**
     * 使用JDK动态代理类
     * @param userServiceInterface
     * @return
     */
    public static UserService getProxy(final UserService userServiceInterface){
        /**
         * proxy是jdk中的代理类
         * 1.目标对象的类加载器
         * 2.目标对接的接口
         * 3.代理对象的执行处理器
         */
     UserService userService = (UserService) Proxy.newProxyInstance(userServiceInterface.getClass().getClassLoader(), userServiceInterface.getClass().getInterfaces(), new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("记录日志-开始");
                //下面的代码是,反射中的api用法
                //方法
                //2.参数
                //这行代码实际还是调用目标对象的方法
                Object invoke = method.invoke(userServiceInterface, args);
                System.out.println("记录日志结束");
                return invoke;
            }
        });
        return userService;
    }

    /**
     * 使用cglib的方式动态代理技术实现
     * 它是基于继承的方式实现的
     * @param userService
     * @return
     */
    public static UserService getProxyByCglib(UserService userService){

        //创建增强器
        Enhancer enhancer =new Enhancer();
        //这里设置增强类的类对象-实现类的类对象
        enhancer.setSuperclass(UserServiceImpl.class);
        //设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param o
             * @param method
             * @param args 方法参数
             * @param methodProxy 代理之后的对象的方法
             * @return
             * @throws Throwable
             */
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {


                long start = System.currentTimeMillis();
                System.out.println("cglib 记录开始时间:  "+start);
                //代理对象是目标的对象的子类
                //这行代码实际还是调用目标对象的方法
                //o 是代理对象
                Object object = methodProxy.invokeSuper(o, args);
                long end = System.currentTimeMillis();
                System.out.println("cglib 记录结束时间:  "+end);
                return object;
            }
        });
        // 获取增强之后的代理对象.
        return (UserService) enhancer.create();
    }

}

我们的测试类

public class MyProxyUtilsTest {


    @Test
    public void testjdkProxy(){
        UserService userService = new UserServiceImpl();
        UserService proxy = MyProxyUtils.getProxy(userService);

        userService.save();
        System.out.println("===========");
        proxy.save();

    }

    @Test
    public void testCglibProcy(){
        UserService userService = new UserServiceImpl();
        UserService proxy = MyProxyUtils.getProxyByCglib(userService);

        userService.save();
        System.out.println("===========");
        proxy.save();
    }

}
userserviceimpl save方法
===========
cglib 记录开始时间: 1556369092690
userserviceimpl save方法
cglib 记录结束时间: 1556369092700

View Code