@Repository
public class UserDaoImpl implements UserDao {
	public void save() {
		System.out.println("保存用户...");
	}

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

/*
 * 通过@Aspect把这个类标识管理一些切面
 */
@Aspect
@Component
public class FirstAspect {	

	/*
	 * 定义切点及增强类型
	 */
	@Before("execution(* save(..))")
	public void before(){
		System.out.println("我是前置增强...");
	}
}

        配置的时候要引入aop命名空间及打开@AspectJ切面驱动器

<?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:p="http://www.springframework.org/schema/p"
	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-3.0.xsd">	
	<context:component-scan base-package="cn.framelife.spring"></context:component-scan>
	<!—
驱动器自动为Spring容器中那些匹配@AspectJ切面的Bean创建代理，完成切面积入 
-->
	<aop:aspectj-autoproxy/>

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserDao userDao = (UserDao) context.getBean("userDaoImpl");
		userDao.save();
		userDao.delete();

我是前置增强...
保存用户...
删除用户...

          @Before(value= "切入点表达式或命名切入点",argNames = "指定命名切入点方法参数列表参数名字，可以有多个用“,”分隔")

          3.6.1中的增强使用：@Before(value="execution(*save(..))")是缺省了value，直接键入值。

a、目标类

@Service
public class UserService {
	public void say(String name){
		System.out.println("service say:"+name);
	}
	
	public void run(String way){
		System.out.println("service run:"+way);
	}
}

@Aspect
@Component
public class BeforAspectj {
	
/*
	 *单独配置切点。给切点命名。
*/
	@Pointcut(value="execution(* say(..)) && args(param)",argNames="param")
	public void beforePointcut(String param){ }
	
	@Before(value="beforePointcut(s)",argNames="s")
	public void beforeAdvice(String s){
		System.out.println("beforeAdvice:"+s);
	}
}

@Aspect
@Component
public class BeforAspectj {
	@Before(value="execution(* say(..)) && args(s)",argNames="s")
	public void beforeAdvice(String s){
		System.out.println("beforeAdvice:"+s);
	}
}

<?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:p="http://www.springframework.org/schema/p"
	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-3.0.xsd">	
	<context:component-scan base-package="cn.framelife.spring"></context:component-scan>

	<aop:aspectj-autoproxy/>

ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
		UserService service = (UserService) context.getBean("userService");
		service.say("zhangsan");
		service.run("street");

beforeAdvice:zhangsan
service say:zhangsan
service run:street

@After

JamesGore119@gmail.com

       企业信息系统集成是一个很大的主题，常见的集成手段有基于ESB、消息总线等。本文所提到的基于插件的服务集成方式，与信息系统集成没有太多的关联，主要是指系统内，多组件架构集成的一种方式。

       在一个企业应用系统中，很少有一个组件或一个工程去满足所有的需求（除非系统很小），一般会纵向分层，横向分包，根据不同的问题领域折分成不同的组件。如一个典型的企业系统有认证、授权、审计、导航等，每个组件专注于所属问题领域，并对外提供服务。基于SOA的架构，这种方式更流行。每个服务组件对外提供服务，客户端（这里指调用程序）依赖于接口服务，不依赖于服务实现。服务实现可以在集成时进行指定，也就是部署或运行时，绑定服务接口及其实现，而非编译时连接。

       这种方式带来的好处：

1.       减耦，封装变化

将实现与接口隔离，不仅从设计上分离，更从物理上分离，接口与实现分别在不同的包中。使得客户端依赖服务接口包，只关注接口提供的服务，服务实现在满足接口语义的前提下，任务变化都与客户端隔离。

2.       可插拨，可替换

服务实现依赖服务接口，但服务接口不依赖服务实现，客户端依赖于服务接口，这样通过插件机制，可在不同的环境使用不同的实现。如依据服务组件与调用程序是否部署在同一进程中，客户端调用的服务实现就可能不一样。

3.       利于团队协作与开发、测试

客户程序与服务组件可能是不同的团队或不同的人进行开发，典型的场景是有人开发界面，有人开发后端服务。定义完服务接口后，前端与后端可同时进行。前端可利用服务桩，加快前端开发进程，隔离外部依赖。

       在开源世界中，一个典型的例子是SLF4J，如下图：

       应用程序只依赖slf4j-api.jar，具体实现可在部署时配置。

       基于插件的服务集成方式，需要解决的一个核心问题是，怎么样实例化其实现？

       基于插件进行服务集成，先得分离接口，然后在运行时，根据部署或配置，将接口与实现绑定。

       实现类对接口存在依赖关系，反之却不然。这就意味着你可以将接口和实现放在不同的包中，实现包依赖接口包，客户端依赖接口包，而与实现包没有依赖关系。

       根据环境和用途，接口可以有不同的实现包，如提供给客户端临时开发和测试的Fake实现；嵌入到客户端，和客户端一起部署的直接实现；和客户端部署在不同进程当中，用于访问远程服务的代理实现。

       如果仅有接口，系统也无法工作了，将接口与实现连接起来，常见方法有：

1)       硬编码

SLF4J就是一个典型的例子，LoggerFactory类直接编码StaticLoggerBinder类，每个实现包必须提供一个全限定名相同的StaticLoggerBinder的绑定类。

2)       第三方实例化

用一个独立的包来连接接口与实现类，这个包与接口及其实现皆有关联，如在应用程序启动时实例化实现类。

3)       插件

插件是实现绑定的一种机制，不仅可以消除依赖，可以推迟到配置或部署时再决定使用哪一个实现类。

       前两种方法，一般会定义一个抽象工厂，负责类的创建、组装及表达。

       类图如上，接口与实现连接描述在统一地方进行声明，以便配置具有可管理性。可以用文本管理连接规则，PluginFactory只不过简单地读取文本文件，返回特定的实现类，在具有反射机制的程序语言中可以充分发挥其优势，调用过程如下：

       在实际应用当中，可能更复杂，如处理本地调用与远程调用，而远程调用基于REST等技术，本身就依赖于一些其它中间件（如cxf），插件工厂就可以分为本地工厂和远程调用工厂，远程调用中间件相关的技术封装在远程工厂当中。这当中可以使用Service Locator模式，对外提供一致服务。

       实例来源于实际项目

       组件提供RESTFull方式开放服务，也提供内嵌到客户端的方式开放服务。

       插件基于Spring实现，Spring提供了一个天然的配置场所。

       ServiceFactory对外提供统一的服务，配置信息都在Spring中统一维护，ServiceConfig提供接口与实现类的配置信息，ServiceRevoler负责创建具体实现类，具体实现也可基于Spring配置。调用过程如下：

       接口与实现类的配置放在每个实现包中，集成时，只要加载对应实现包中的配置就可以。

       这样，不管在后台开发，还是前台开发，使用统一的调用方式，由配置去决定实际是哪个实现类，达到比较灵活的集成方式。

.....  原创文章，转载请注明出处, 本文地址：http://blog.csdn.net/jamesgore/article/details/9275689  ......

参考：

1. 《企业应用架构模式》

2. 《Core J2EE Patterns》

   E.避免系统随着时间推移越来越大，难维护的问题！

技术官网：www.jeecg.org