富客户端程序设计实例 - Bean(DAO+Service层) - Spring 为什么要对 Bean 进行托管？

11年前

        换句话就是Spring进行依赖注入的好处是什么。以BaseService、EmployeeServiceImpl和EmployeeAction
这三个类为例，部分代码如下所示：
  1. public interface BaseService  
  2. {   
  3.     public <T> List<T> find(Class<T> cla);   
  4.       
  5.     public <T> void saveOrUpdate(List<T> list);  
  6.    
  7.     public <T> void delete(List<T> list);  
  8.   
  9.     public <T> void saveInfo(List<T> list);  
  10.   
  11.     public <T> void updateInfo(List<T> list);  
  12. }  
  13. ===========================================================  
  14. @Service  
  15. public class EmployeeServiceImpl implements BaseService  
  16. {  
  17.     private BaseDao employeeDao;  
  18.   
  19.     public BaseDao getBaseDao()  
  20.     {  
  21.         return employeeDao;  
  22.     }  
  23.     @Resource  
  24.     public void setBaseDao(BaseDao employeeDao)  
  25.     {  
  26.         this.employeeDao = employeeDao;  
  27.     }  
  28.   
  29.   
  30.     public <T> List<T> find(Class<T> cla)  
  31.     {  
  32.         return employeeDao.find(cla);  
  33.     }  
  34.   
  35.     public <T> void saveOrUpdate(List<T> list)  
  36.     {  
  37.         employeeDao.saveOrUpdate(list);  
  38.     }  
  39.   
  40.     public <T> void delete(List<T> list)  
  41.     {  
  42.          employeeDao.delete(list);  
  43.     }  
  44.   
  45.     public <T> void saveInfo(List<T> list)  
  46.     {  
  47.          employeeDao.saveInfo(list);  
  48.     }  
  49.   
  50.     public <T> void updateInfo(List<T> list)  
  51.     {  
  52.           employeeDao.updateInfo(list);  
  53.     }  
  54. }  
  55.   
  56. ================================================================  
  57. public class EmployeeAction extends BaseAction  
  58. {  
  59.     private Logger log = LoggerFactory.getLogger(Employee.class);    
  60.    
  61.     public void read()  
  62.     {  
  63.         String jsonStr = ajaxJson(service.find(Employee.class));  
  64.     }  
  65.    
  66.     public void add()  
  67.     {  
  68.         System.out.println("add() begain |");   
  69.         String jsonStr = getJsonFromRequest();  
  70.         List<Employee> empList = new ArrayList<Employee>();   
  71.         empList.add(getObjectFromJson(jsonStr, Employee.class));   
  72.         service.saveInfo(empList);   
  73.     }  
  74.    
  75.     public void update()  
  76.     {  
  77.         System.out.println("update() begain |");  
  78.         String jsonStr = getJsonFromRequest();  
  79.         List<Employee> empList = new ArrayList<Employee>();  
  80.         empList.add(getObjectFromJson(jsonStr, Employee.class));   
  81.         service.updateInfo(empList);   
  82.     }  
  83.    
  84.     public void destroy()  
  85.     {  
  86.         String jsonStr = getJsonFromRequest();  
  87.         List<Employee> empList = getListFromJson(jsonStr, Employee.class);  
  88.         service.delete(empList);    
  89.     }    
  90. }  
        可以看到，在Action层的这个类( EmployeeAction继承了BaseAction EmployeesAction是被间接托管 )里面，我们并没有看到EmployeeServiceImpl的身影，也就是说我们并不关心这个实现类是谁，我们通过BaseService这个接口去引用注入进来的对象，在通过接口调用它的方法；这是设计模式中典型的简单工厂模式。这样Action层的组件和服务层的组件就彻底的解耦了。同样的道理，服务层和DAO层也是这样解耦的。

       这种解耦方式和你使用 new 关键字的区别
       如果项目很大，Action很多，而且大部分Action都用到了EmployeeServiceImpl 这个服务层的类，你用new这种方法进行创建那么每个Action里都会耦合到“EmployeeServiceImpl”。现在需求有变，用其他的服务类了，比如：ManagerServiceImpl.java。你怎么更改这些new的对象？一个Action中的代码几百行，你怎么去找到？精力上的消耗会非常大。但是用Spring对Bean进行托管的方式则会简单的多。假设：ManagerServiceImpl.java 和 EmployeeServiceImpl.java 一样，他们都继承自BaseService.java。如果我现在要替换一个类，只需要更改为需要的类就可以了，一般只需要改一次即可。

如果你用配置文件的方式托管Bean，则：
<bean id="managerAction" class="org.hongbo.Yangcl.action.ManagerAction">     
            <property name="BaseService" ref="BaseService"></property>     
</bean> 
如果你使用注解的方式托管Bean，则：直接删除掉EmployeeServiceImpl类上的@Service标记即可，在 ManagerServiceImpl 上加上@Service标记
个人推荐使用注解的方式，因为配置文件的方式还是比较纷乱。