这篇接着上篇，把没贴完的代码写完，上篇主要完成了一些公共配置和界面的东西，这篇把后台的代码完成。

首先是web包下属于的control层的类UserController，这相当于Struts中的Action，是重要的类：

package com.tgb.web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.tgb.entity.User;
import com.tgb.manager.UserManager;

@Controller
@RequestMapping("/user")
public class UserController {

	@Resource(name="userManager")
	private UserManager userManager;

	@RequestMapping("/getAllUser")
	public String getAllUser(HttpServletRequest request){
		
		request.setAttribute("userList", userManager.getAllUser());
		
		return "/index";
	}
	
	@RequestMapping("/getUser")
	public String getUser(String id,HttpServletRequest request){
		
		request.setAttribute("user", userManager.getUser(id));
	
		return "/editUser";
	}
	
	@RequestMapping("/toAddUser")
	public String toAddUser(){
		return "/addUser";
	}
	
	@RequestMapping("/addUser")
	public String addUser(User user,HttpServletRequest request){
		
		userManager.addUser(user);
		
		return "redirect:/user/getAllUser";
	}
	
	@RequestMapping("/delUser")
	public void delUser(String id,HttpServletResponse response){
		
		String result = "{\"result\":\"error\"}";
		
		if(userManager.delUser(id)){
			result = "{\"result\":\"success\"}";
		}
		
		response.setContentType("application/json");
		
		try {
			PrintWriter out = response.getWriter();
			out.write(result);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	@RequestMapping("/updateUser")
	public String updateUser(User user,HttpServletRequest request){
		
		if(userManager.updateUser(user)){
			user = userManager.getUser(user.getId());
			request.setAttribute("user", user);
			return "redirect:/user/getAllUser";
		}else{
			return "/error";
		}
	}
}

然后是属于manager包下的业务逻辑类，接口UserManager：

package com.tgb.manager;

import java.util.List;

import com.tgb.entity.User;

public interface UserManager {

	public User getUser(String id);
	
	public List<User> getAllUser();
	
	public void addUser(User user);
	
	public boolean delUser(String id);
	
	public boolean updateUser(User user);
}

实现类UserManagerImpl：

package com.tgb.manager;

import java.util.List;

import com.tgb.dao.UserDao;
import com.tgb.entity.User;

public class UserManagerImpl implements UserManager {

	private UserDao userDao;
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public User getUser(String id) {
		return userDao.getUser(id);
	}

	@Override
	public List<User> getAllUser() {
		return userDao.getAllUser();
	}

	@Override
	public void addUser(User user) {
		userDao.addUser(user);
	}

	@Override
	public boolean delUser(String id) {
		
		return userDao.delUser(id);
	}

	@Override
	public boolean updateUser(User user) {
		return userDao.updateUser(user);
	}

}

最后是属于dao包底下的DAO层，主要由Hibernate完成。接口UserDao：

package com.tgb.dao;

import java.util.List;

import com.tgb.entity.User;

public interface UserDao {

	public User getUser(String id);
	
	public List<User> getAllUser();
	
	public void addUser(User user);
	
	public boolean delUser(String id);
	
	public boolean updateUser(User user);
}

实现类UserDaoImpl：

package com.tgb.dao;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.SessionFactory;

import com.tgb.entity.User;

public class UserDaoImpl implements UserDao {

	private SessionFactory sessionFactory;

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	
	@Override
	public User getUser(String id) {
		
		String hql = "from User u where u.id=?";
		Query query = sessionFactory.getCurrentSession().createQuery(hql);
		query.setString(0, id);
		
		return (User)query.uniqueResult();
	}

	@Override
	public List<User> getAllUser() {
		
		String hql = "from User";
		Query query = sessionFactory.getCurrentSession().createQuery(hql);
		
		return query.list();
	}

	@Override
	public void addUser(User user) {
		sessionFactory.getCurrentSession().save(user);
	}

	@Override
	public boolean delUser(String id) {
		
		String hql = "delete User u where u.id = ?";
		Query query = sessionFactory.getCurrentSession().createQuery(hql);
		query.setString(0, id);
		
		return (query.executeUpdate() > 0);
	}

	@Override
	public boolean updateUser(User user) {
		
		String hql = "update User u set u.userName = ?,u.age=? where u.id = ?";
		Query query = sessionFactory.getCurrentSession().createQuery(hql);
		query.setString(0, user.getUserName());
		query.setString(1, user.getAge());
		query.setString(2, user.getId());
		
		return (query.executeUpdate() > 0);
	}

}

最后外加一个配置spring-beans.xml，放在config.spring包下，负责为各层依赖注入需要的对象：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi=      

      
      
    

      

代理，大家都知道是什么意思。百科上面的解释：以他人的名义，在授权范围内进行对被代理人直接发生法律效力的法律行为。

说白了就是A想交女朋友，但是自己不敢去表白，然后叫B去帮他送花，而B帮助A送了花，B就是代理。

而代理又分为静态代理和动态代理，那么什么是静态代理呢？

仍然是上面的例子，A想交女朋友，然后就就跟B说：B啊，咱俩是哥们儿，我喜欢那么女生，你要帮我送一束花，帮我送洋娃娃，帮我送巧克力……然后A想送的时候，就叫B去送相应的东西。

动态代理是：A告诉B，你去帮我送花，然后B就去送花；A又说你去帮我送洋娃娃，B就又去送洋娃娃……

那么静态代理和动态代理有什么区别呢？静态代理提前都知道要帮A做那些事儿，有心理准备，行动起来比较快。但是由于A非常啰嗦，A需要表达强烈的爱意，跟B说了一大顿，B都需要记下A要干啥，到时候去帮A做。

而动态代理是，B一直忙自己的事儿，当A有需求的时候，就帮A去送东西，由于A没有提前告知B要送什么，所以B要去现准备，所以需要花费一些时间去准备。

好了，说了这么多废话，就是为了用我自己的理解讲解一下代理模式。下面进行正题——动态代理。

所谓动态代理，就是在运行时动态地创建一个代理类，实现一个或多个接口，并将方法的调用转发到你所指定的类。

Proxy代理完全是java创建的，并且实现完整的subject接口。

InvocationHandler：Proxy上的任何方法调用都会被传入此类，InvocationHandler控制对RealSubject具体行为类的访问。

sun已经帮我们创建好了代理类Proxy，我们需要做的就是告诉Proxy：我们要做什么。我们不能像以前一样将代码写入到Proxy中，因为它不是我们创建的。如果我们自己创建Proxy，那就是静态代理了，这里会有大量的重复代码，是我们不想看到的。由于InvocationHandler能够响应代理的任何调用，我们可以把InvocationHandler想成是代理收到方法调用后，请求做际工作的对象。

下面通过动态代理封装事务的例子进行讲解：

事务在之前的项目中一直是加在Manager层，Manager层调用不同的dao方法，同时负责开启事务，执行事务等。而由于每个Manger层的每个方法里面除了要关心业务逻辑之外，都需要负责事务的开关。其实事务是单独的逻辑，我们可以动态代理分离开来。

package com.xxjstgb.drp.util;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;

/**
 * 采用动态代理封装事务
 * 
 * @author liuzhengquan
 * 
 */
public class TransactionHandler implements InvocationHandler {

	//要处理的对象，声明为Object类型是为了通用性
	private Object targetObject;
	
	//动态生成方法被处理过后的对象 
	public Object newProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		/**
		 * 参数1：类的加载器
		 * 参数2：确定继承类的接口
		 */
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), 
				this);
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Connection conn = null;
		Object ret = null;
		try {
			//取得Connection
			conn = ConnectionManager.getConnection();
			//System.out.println(method.getName());
			/*
			 * 判断Manager层调用的什么方法，调用该方法时，自动开始事务
			 *注：此处DRP视频中有错误
			 */
			if(method.getName().startsWith("addFlowCard") || 
			   method.getName().startsWith("delFlowCard") || 
			   method.getName().startsWith("modifyFlowCard") || 
			   method.getName().startsWith("findFlowCardList") || 
			   method.getName().startsWith("findClient") || 
			   method.getName().startsWith("findAimClient") 
			   ){
				System.out.println(method.getName());
				// 手动开启事务
				ConnectionManager.beginTransaction(conn);
			}
			//调用目标对象的业务逻辑方法
			ret=method.invoke(targetObject, args);
			if(!conn.getAutoCommit()){
				//提交事务
				ConnectionManager.commitTransaction(conn);
			}
		}catch(Exception e){
			e.printStackTrace();
			//使用代理后，代理用InvocationTargetException包装了异常
			if(e instanceof InvocationTargetException){
				InvocationTargetException ete=(InvocationTargetException)e;
				throw ete.getTargetException();
			}
			if(!conn.getAutoCommit()){
				//回滚事务
				ConnectionManager.rollbackTransaction(conn);
			}
			throw new ApplicationException("操作失败！");
		}
		finally{
			//关闭事务，并删除连接
			ConnectionManager.closeConnection();
		}
		return ret;
	}

}

这里的Invoke方法，当代理的方法被调用的时候，代理就会把这个调用转发给InvocationHandler，也就会调用它的invoke()方法。在Invoke方法里面，能够得到RealSubject具体行为方法，并且能够定义新的行为，也就是这里的事务操作。

对应Servlet的调用：

public class FlowCardServlet extends HttpServlet {
	//私有声明具体行为类对象
	private FlowCardManager flowCardManager;
	@Override
	public void init() throws ServletException {
		flowCardManager=(FlowCardManager)getBeanFactory().getServiceObject(FlowCardManager.class);
		//采用动态代理包装service
		TransactionHandler transactionHandler=new TransactionHandler();
		//对目标生成代理对象
		flowCardManager=(FlowCardManager)transactionHandler.newProxyInstance(flowCardManager);
	}
     }

这样我们就创建了flowCardManager代理，当我们想调用Manager层的方法等，我们就可以通过在Servlet方法中通过使用flowCardManager代理对象，进行事务操作以及Manager层方法调用。

动态代理的应用非常广范，比如WebService的应用，其实就是动态代理的一个应用。我们对WebService添加的引用，其实就是一个远程代理，然后客户端通过代理能够进行远程访问。

生活中和实际应用中还有很多，都有代理的原型。希望大家多多与我交流，共同进步。