spring的IOC和AOP

 

           关于Spring，大家都是耳熟能详，在开发中基本到处都在使用，Spring有好几个模块，对于初学者来说，学习Spring可能会摸不到门道，这么多的模块，该从哪学习好呢？其实我最开始学习Spring的时候，也是不知所云，后来慢慢的，用的多了，看得也多了，对Spring有了一些自己的体会心得，Spring最核心的是IOC模块和AOP模块。

 

          IOC模块在我们周围都被翻译为”控制反转“ 其实最开始我看到这个词也觉得挺奇怪的，不好理解，首先谈“控制”，控制什么呢？我们面向对象的程序员一般都知道，在我们开发的过程中，在不同的类里一般需要实例化出各种各样的对象，也就是一个类里面会引用其他类的实例。最简单的做法：

 

ObjectA objA =new ObjectA(); 

 

    

需要就new 一个呗，这样一来，我们一个项目做下来，发现导出都是在new 对象，这样就造成了代码的紧耦合度，这与我们面向对象的可扩展，可维护，可重用的思想是严重不符的。这里，所谓的”控制“，就是当我们需要一个对象的时候，就自己去New一个，自己来控制对象的生死。

 

    在说“反转” ，当我们项目中使用了Spring以后，一个项目做完了，细心的同学就会发现，项目里面 New出现的频率明显降低了，取而代之的是一个一个的配置文件：Spring2.5以前，我们配置的是一个一个Bean定义。比如：

 

<bean id="cureResultDao" class="com.nbey.data.forward.mongo.business.impl.CureResultDao" />
<bean id="ecgResultDao" class="com.nbey.data.forward.mongo.business.impl.EcgResultDao" />

 

 

在使用的时候：

 

	public static synchronized ApplicationContext getApplicationContext() {
		if (applicationContext == null) {
			applicationContext = new ClassPathXmlApplicationContext(
					configLocations);
		}
		return applicationContext;
	}

 

 

 

	IEcgResultDao ecgResultDao = getApplicationContext().getBean(
					"ecgResultDao", EcgResultDao.class);

 看起来依然是比较繁琐，需要配置定义很多个Bean，但是我们的确不用在项目里面直接去New了，这里我们需要的对象，由Spring自己去生产，所有定义的对象都有Spring来管理，需要的时候给你！这里 ，也就是 “对象的管理权限被反转给了Spring了”    ，好在有了Java的注解以后，使用注解可以大大减轻XML里面的Bean的定义

 

 

	<context:annotation-config/>
	<context:component-scan base-package="com.zhuyun.nbey.controller" />
	<context:component-scan base-package="com.zhuyun.nbey.business.manager" />
	<context:component-scan base-package="com.zhuyun.nbey.mysql.business" />

 

 

 

@Controller
public class AppController {

	@Autowired
	private IBrjbxxDao brjbxxDao;

	@Autowired
	private IJzsjDao jzsjDao;

	@Autowired
	private IGhxxbDao ghxxDao;

	@Autowired
	private IZybrxxDao zyxxDao;

   利用注解已经比较简单的实现了Bean的装配，这里“控制反转”就将完了

 

 

   接下来，是AOP ，AOP的设计思想是代理模式的一种实现，这种思想可以用于很多的场景，代理分为两类一个是Java的代理，基于接口的，这种代理一个业务一个代理者，称之为静态代理了，另外就是cglib的动态代理，可以拦截方法的调用请求，加上自己的业务逻辑，Spring里面对它进行了实现。例如，如下代码片段

 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mchz.brook.jdbc.facade.ConnectionAspectFacade;
import com.mchz.brook.jdbc.facade.SqlLogAspectFacade;

public  class PreparedStatementLoggingProxy implements InvocationHandler {

	static final Logger logger = LoggerFactory.getLogger(PreparedStatementLoggingProxy.class);
	
	
    Object target = null;
	
	String sql = null;
	
		
	static List setMethods = Arrays.asList(new String[]{"setAsciiStream", "setBigDecimal", "setBinaryStream"
			, "setBoolean", "setByte", "setBytes", "setCharacterStream", "setDate", "setDouble", "setFloat"
			, "setInt", "setLong", "setObject", "setShort", "setString", "setTime", "setTimestamp", "setURL"});
	
	static List executeMethods = Arrays.asList(new String[]{ "execute", "executeQuery", "executeUpdate","executeBatch"});
	
	public  PreparedStatementLoggingProxy(Object ps, String sql){
		target=ps;
		this.sql=sql;
	}
	
	public  Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object r = null;
		try {
			long t1 = 0;
			boolean toLog = (StatementLogger.logger.isInfoEnabled()
					|| SlowQueryLogger.logger.isInfoEnabled()) && executeMethods.contains(method.getName());
			if(toLog)
				t1 = System.currentTimeMillis();
			
			if(executeMethods.contains(method.getName())){
				ConnectionAspectFacade.createStatementAdvice(target);
			}
			r = method.invoke(target, args);
		} catch(Throwable t) {
			LogUtils.handleException(t, StatementLogger.logger, LogUtils.createLogEntry(method, sql, null, null));
		}
		
		
		return r;
	}
	

	protected void executeLogAdvice(Method method) {
		try{
			if(executeMethods.contains(method.getName())){
				SqlLogAspectFacade.logAdvice(sql);
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	

 

Spring AOP相关概念

Aspect(切面)
给业务类中要加入的非业务功能，如日志，事务，安全等，即：要实现的系统需求。
Advice(通知)
在上面示例中，日志功能可能非常通用，如果把日志功能做成一个类，在使用的时候只
调用那就非常放便，那么这个类可以称之为对某个
Aspect(切面)
的具体实现，即通知。
所以切面是一个概念意义上的，而通知才是具体的实现。
Joinpoint(连接点
Pointcut（切入点）
Joinpoint(连接点），应用到目标对像。
Target(目标对像)将要被代理的对像（一般为业务接口）
Weave(织入)
把通知应用到目标对象，最后生成代理对象的过程叫织入
Advices:
前面已提到过，是一个通知，是切面的具体实现。但是在什么时候去使用通知，

spring用连接点来进行了描述，但是其只是一个概念级别的事物，如何具体的实施呢？在

spring中把通知和连接点合二为一，来进行实施。从而生成了四种类型的通知，分别如下：

BeforeAdvice（前置通知）

org.springframework.aop.MethodBeforeAdvice

AfterAdvice(后置通知)

AroundAdvice(环绕通知)
org.aopalliance.intercept.MethodInvocation

ThrowAdvice(异常通知)
org.springframework.aop.ThrowsAdvice