Spring02-AOP

1，动态代理，指的是通过一个代理对象创建需要的业务对象，然后在这个代理对象中统一进行各种操作。

步骤：

1）写一个类实现InvocationHandler接口；

2）创建要代理的对象

2，创建一个简单的打印日志的类Logger

package com.yangw.spring.proxy;

import java.util.Date;

public class Logger {

    public static void info(String msg){
        System.out.println(new Date()+"----"+msg);
    }
}

3，自定义注解类

package com.yangw.spring.model;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface LogInfo {

    public String value() default "";

}

4，自定义动态代理类LogProxy

package com.yangw.spring.proxy;

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

import com.yangw.spring.model.LogInfo;
/**
 * 1 写一个类，实现InvocationHandler接口
 * @author Administrator
 *
 */
public class LogProxy implements InvocationHandler {
    //2,创建代理对象
    private Object target;
    private LogProxy(){};

    //3,创建一个方法来生成代理对象，这个方法的参数是要代理的对象
    public static Object getInstance(Object obj){
        //3.1  创建LogProxy对象
        LogProxy proxy=new LogProxy();
        //3.2 设置代理对象
        proxy.target=obj;
        //3.3 通过Proxy.newProxyInstance()创建代理对象
        //参数1：要代理对象的classloader，参数2:要代理对象的实现的所有接口，
        //参数3:实现InvocationHandler接口的对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), proxy);

    }
    /**
     * 当有了代理对象之后，都会调用下面的invoke()方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //这里怎么处理完全由我们来控制的
        /*if(method.getName().equals("add")|| method.getName().equals("delete")){
            Logger.info("调用我...");
        }*/
        //只对有LogInfo注解的进行处理，
        //而且是在method.invoke调用之前，调用之后执行都可以
        //在异常中进行处理也可以
        if(method.isAnnotationPresent(LogInfo.class)){
            Logger.info(method.getAnnotation(LogInfo.class).value());
        }
            return method.invoke(target, args);
        //aspect orient program (面向切面编程)
    }

}

5，在需要加入注解的接口上面加入自定义注解LogInfo

package com.yangw.spring.dao;

import com.yangw.spring.model.LogInfo;
import com.yangw.spring.model.User;

public interface IUserDao {

    @LogInfo("add a user")
    public void add(User user) ;

    @LogInfo("delete a user")
    public void delete(int id) ;

    public User load(int id);
}

6，beans2.xml中的配置如下

<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-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <!--1, 打开Spring的annotation -->
   <context:annotation-config/>
   <!-- 2, 设定Spring去那些包中找annotation -->
    <context:component-scan base-package="com.yangw.spring" />

    <!--用代理类实现
        对于静态(static)的注入，使用factory-method
    -->
    <bean id="userDynamicDao" class="com.yangw.spring.proxy.LogProxy"
          factory-method="getInstance">
        <!--静态方法传入的参数 -->
        <constructor-arg ref="userDao" />
    </bean>
    <!-- 依次加入想加入的
    <bean id="msgDynamicDao" class="com.yangw.spring.proxy.LogProxy"
          factory-method="getInstance">
        <constructor-arg ref="MsgDao" />
    </bean>
    -->
</beans>

7,UserService类上注入userDynamicDao

package com.yangw.spring.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.yangw.spring.dao.IUserDao;
import com.yangw.spring.model.User;
@Service("userService")
public class UserService implements IUserService {

    @Resource(name="userDynamicDao")
    private IUserDao userDao ;

    @Override
    public void add(User user) {

        userDao.add(user);

    }

    @Override
    public void delete(int id) {

        userDao.delete(id);
    }

    @Override
    public User load(int id) {

        return    userDao.load(id);

    }

}

7，测试

package com.yangw.spring.test;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.yangw.spring.action.UserAction;
import com.yangw.spring.model.User;

public class TestSpring {

     //1,创建Spring工厂
    BeanFactory factory= new ClassPathXmlApplicationContext("beans2.xml");

    @Test
    public void testUser(){

        //2,通过工厂获取Spring的对象
        UserAction userAction = factory.getBean("userAction", UserAction.class);

        User u1=new User(1,"yangw");
        userAction.setUser(u1);
        userAction.add();
        userAction.delete();
        userAction.load();
    }
}

8， Spring实现动态代理（基于annotation方式）

导入aopalliance-1.0.jar aspectjrt-1.6.10.jar aspectjweaver-1.7.2.jar 三个包，Spring使用这三个包实现AOP

<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-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!--1, 打开Spring的annotation -->
   <context:annotation-config/>
   <!-- 2, 设定Spring去那些包中找annotation -->
   <context:component-scan base-package="com.yangw.spring" />

   <!-- 打开基于annotation的aop自动代理 -->
   <aop:aspectj-autoproxy />
</beans>

切面类

package com.yangw.spring.proxy;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component("logAspect") //交给Spring管理
@Aspect //说明是一个切面类
public class LogAspect {

    //前置通知
    // 第1个"*": 任意返回值
    // 第2个"*": com.yangw.spring.dao包中的所有类
    // 第3个"*": add*表示以add开头的所有方法
    // "(..)"  : 表示方法参数是任意值
    // "||"    : 可以用或表达式加入多个条件
    /**
     * 函数调用之前执行
     */
    @Before("execution(* com.yangw.spring.dao.*.add*(..))||"
            +"execution(* com.yangw.spring.dao.*.delete*(..))||"
            +"execution(* com.yangw.spring.dao.*.update*(..))")
    public void logStart(JoinPoint jp){
        System.out.println(jp.getTarget()); //得到执行的类
        System.out.println(jp.getSignature().getName()); //得到执行的方法名
        Logger.info("log start.");
    }
    /**
     * 函数调用之后执行
     */
    @After("execution(* com.yangw.spring.dao.*.add*(..))||"
            +"execution(* com.yangw.spring.dao.*.delete*(..))||"
            +"execution(* com.yangw.spring.dao.*.update*(..))")
    public void logEnd(JoinPoint jp){
        System.out.println(jp.getTarget()); //得到执行的类
        System.out.println(jp.getSignature().getName()); //得到执行的方法名
        Logger.info("log end.");
    }

    /**
     * 函数调用过程中执行
     */
    @Around("execution(* com.yangw.spring.dao.*.add*(..))||"
            +"execution(* com.yangw.spring.dao.*.delete*(..))||"
            +"execution(* com.yangw.spring.dao.*.update*(..))")
    public void logAround(ProceedingJoinPoint pjp) throws Throwable{

        Logger.info("log around start");
        pjp.proceed(); //让程序往下执行
        Logger.info("log around end.");
    }
}

测试

package com.yangw.spring.test;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.yangw.spring.action.UserAction;
import com.yangw.spring.model.User;

public class TestSpring {

     //1,创建Spring工厂
    BeanFactory factory= new ClassPathXmlApplicationContext("beans3.xml");

    @Test
    public void testUser(){

        //2,通过工厂获取Spring的对象
        UserAction userAction = factory.getBean("userAction", UserAction.class);

        User u1=new User(1,"yangw");
        userAction.setUser(u1);
        userAction.add();
        userAction.delete();
        userAction.load();
    }
}

测试结果

Mon Oct 21 19:13:29 CST 2013----log around start
com.yangw.spring.dao.UserDao@18ce14a
add
Mon Oct 21 19:13:29 CST 2013----log start.
add :User [id=1, username=yangw]
Mon Oct 21 19:13:29 CST 2013----log around end.
com.yangw.spring.dao.UserDao@18ce14a
add
Mon Oct 21 19:13:29 CST 2013----log end.
Mon Oct 21 19:13:29 CST 2013----log around start
com.yangw.spring.dao.UserDao@18ce14a
delete
Mon Oct 21 19:13:29 CST 2013----log start.
delete :0
Mon Oct 21 19:13:29 CST 2013----log around end.
com.yangw.spring.dao.UserDao@18ce14a
delete
Mon Oct 21 19:13:29 CST 2013----log end.
load :0
null

9， Spring实现动态代理（基于xml方式）一般这种用的多

导入aopalliance-1.0.jar aspectjrt-1.6.10.jar aspectjweaver-1.7.2.jar 三个包，Spring使用这三个包实现AOP

<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-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!--1, 打开Spring的annotation -->
   <context:annotation-config/>
   <!-- 2, 设定Spring去那些包中找annotation -->
   <context:component-scan base-package="com.yangw.spring" />

   <aop:config>
       <!-- 定义切面 -->
       <aop:aspect id="myLogAspect" ref="logAspect">
           <!-- 在哪些位置加入相应的Aspect-->
           <aop:pointcut id="logPointCut" expression="execution(* com.yangw.spring.dao.*.add*(..))||
                   execution(* com.yangw.spring.dao.*.delete*(..))||
                   execution(* com.yangw.spring.dao.*.update*(..))" />
           <!-- 定义通知 -->
           <aop:before method="logStart" pointcut-ref="logPointCut"/>
           <aop:after method="logEnd" pointcut-ref="logPointCut"/>
           <aop:around method="logAround" pointcut-ref="logPointCut"/>
       </aop:aspect>

   </aop:config>
</beans>

package com.yangw.spring.proxy;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;

@Component("logAspect") //交给Spring管理

public class LogAspect1 {

    public void logStart(JoinPoint jp){
        System.out.println(jp.getTarget()); //得到执行的类
        System.out.println(jp.getSignature().getName()); //得到执行的方法名
        Logger.info("log start.");
    }

    public void logEnd(JoinPoint jp){
        System.out.println(jp.getTarget()); //得到执行的类
        System.out.println(jp.getSignature().getName()); //得到执行的方法名
        Logger.info("log end.");
    }

    public void logAround(ProceedingJoinPoint pjp) throws Throwable{

        Logger.info("log around start");
        pjp.proceed(); //让程序往下执行
        Logger.info("log around end.");
    }
}

测试和结果与前面的基于annotation的一模一样，不在赘述！

Spring02-AOP的更多相关文章

JAVAEE——spring02：使用注解配置spring、sts插件、junit整合测试和aop演示
一.使用注解配置spring 1.步骤 1.1 导包4+2+spring-aop 1.2 为主配置文件引入新的命名空间(约束) 1.3 开启使用注解代替配置文件 1.4 在类中使用注解完成配置 2.将 ...
Spring第二天——IOC注解操作与AOP概念
大致内容 spring的bean管理(注解实现) AOP原理 log4j介绍 spring整合web项目的演示一.spring注解实现bean管理注解: 代码中一些特殊的标记,使用注解也可以完成一 ...
spring-02
spring-02 1.谈谈你对 Spring 的理解 Spring 是一个开源框架,为简化企业级应用开发而生.Spring 可以是使简单的 JavaBean 实现以前只有 EJB 才能实现的功能.S ...
Spring03——有关于 Spring AOP 的总结
本文将为各位带来 Spring 的另一个重点知识点 -- Spring AOP.关注我的公众号「Java面典」,每天 10:24 和你一起了解更多 Java 相关知识点. 什么是 AOP 面向切面编程 ...
基于spring注解AOP的异常处理
一.前言项目刚刚开发的时候,并没有做好充足的准备.开发到一定程度的时候才会想到还有一些问题没有解决.就比如今天我要说的一个问题:异常的处理.写程序的时候一般都会通过try...catch...fin ...
Spring基于AOP的事务管理
Spring基于AOP的事务管理事务事务是一系列动作,这一系列动作综合在一起组成一个完整的工作单元,如果有任何一个动作执行失败,那么事务 ...
学习AOP之透过Spring的Ioc理解Advisor
花了几天时间来学习Spring,突然明白一个问题,就是看书不能让人理解Spring,一方面要结合使用场景,另一方面要阅读源代码,这种方式理解起来事半功倍.那看书有什么用呢?主要还是扩展视野,毕竟书是别 ...
学习AOP之深入一点Spring Aop
上一篇<学习AOP之认识一下SpringAOP>中大体的了解了代理.动态代理及SpringAop的知识.因为写的篇幅长了点所以还是再写一篇吧.接下来开始深入一点Spring aop的一些实 ...
学习AOP之认识一下Spring AOP
心碎之事要说知道AOP这个词倒是很久很久以前了,但是直到今天我也不敢说非常的理解它,其中的各种概念即抽象又太拗口. 在几次面试中都被问及AOP,但是真的没有答上来,或者都在面上,这给面试官的感觉就是 ...
.Net中的AOP系列之构建一个汽车租赁应用
返回<.Net中的AOP>系列学习总目录本篇目录开始一个新项目没有AOP的生活变更的代价使用AOP重构本系列的源码本人已托管于Coding上:点击查看. 本系列的实验环境:VS ...

随机推荐

unity slua整合帅气的lua-pb解析protobuf
了解到lua的一个protobuf库,接口帅气,比之前用过的一些lua protobuf库要好很多,深得我心.而且能保持更新,比其他库几年没更新要放心. lua-pb动态解析protobuf协议,无需 ...
使用百度云同步盘和Git Extensions进行代码托管
一.软件安装百度云同步盘和Git Extensions的安装和配置略过. 二.建立Git代码库,以[GHO2VMDK转换工具]项目为例 1. 建立本地代码库进入[GHO2VMDK转换工具]项目文件 ...
C++编程规范（不断更新）
本文总结一些经验教训,以使编出来的代码更为健壮. 1.定义类/结构体的时候不要和系统函数冲突(尤其是不同系统/平台之间移植的时候) 有时候在windows系统下编译没问题,但是在linux系统下就不行 ...
hadoop系列四:mapreduce的使用(二)
转载请在页首明显处注明作者与出处一:说明此为大数据系列的一些博文,有空的话会陆续更新,包含大数据的一些内容,如hadoop,spark,storm,机器学习等. 当前使用的hadoop版本为2.6 ...
高CPU业务场景下的任务分发方案Gearman搭建一览
Gearman是当年LiveJournal用来做图片resize的,大家也明白图片resize是一个高CPU的操作,如果让web网站去做这个高CPU的功能,有可能会拖垮你的 web应用,那本篇我们 ...
javascript一些比较难理解的知识点
原文出处:https://segmentfault.com/a/1190000010371988 看了一下这篇文章,自己也手敲了一遍 //1. 立即执行函数作用:将var变量的作用域限制于函数内,这 ...
学习Java第一天，大致了解
第一章: java核心 1 了解 java的产生背景 2 了解java的体系结构和组成 3 了解java程序的编写编译运行 4 掌握java的 api文档的使用 5 了解 jdk的组成 1. ja ...
MySQL存储引擎中的MyISAM和InnoDB区别
MyISAM是MySQL的默认数据库引擎(5.5版之前),由早期的ISAM(Indexed Sequential Access Method:有索引的顺序访问方法)所改良.虽然性能极佳,但却有一个缺点 ...
java常量池中基本数据类型包装类的小陷阱
想必大部分学过java的人都应该做过这种题目: public class Test { public static void main(String[] args) { //第一个字符串 String ...
ActiveMQ笔记——技术点汇总
目录 · Introduction to ActiveMQ · Installing ActiveMQ · Message-oriented middleware · JMS specificatio ...

Spring02-AOP

Spring02-AOP的更多相关文章

随机推荐

热门专题