51CTO下载大型门户网站是这样炼成+这个只是spring+部分.docx

51CTO下载大型门户网站是这样炼成+这个只是spring+部分.docx

《51CTO下载大型门户网站是这样炼成+这个只是spring+部分.docx》由会员分享，可在线阅读，更多相关《51CTO下载大型门户网站是这样炼成+这个只是spring+部分.docx（82页珍藏版）》请在冰豆网上搜索。

51CTO下载大型门户网站是这样炼成+这个只是spring+部分

这个只是spring部分

6.1.3 Spring2.5拿手戏--控制反转与依赖注入

人类社会由数以亿计的拥有不同本领的人组成，通过这些人的不同分工协作完成了许多不可思议的惊天杰作，从而呈现出一幅又一幅美妙的生活全景图。

我们习惯将这种组合称为团队，团队讲求的是分工与协作，谁也离不开谁。

在JavaEE的世界里，充满了身怀绝技的Java类，通过这云云Java类的分工协作，造就了五彩缤纷的JavaEE应用王国。

当我们需要别人的帮助才能完成某项工作时，毫不犹豫地就会想到"请"，这种"请"无疑是一种盛情的、主动的"请求"。

沿用这种处事风格，我们的JavaEE应用开发走过了漫长的"请"的岁月。

例如：

1./** 负责处理用户管理底层数据访问 */ 

2.public class UserDao{ 

3.    //保存用户数据 

4.    public void saveUser（User user）{ 

5.        //进行数据的保存工作，省略代码 

6.    } 

7.    ......   

8.} 

9. 

10./** 负责处理用户管理业务逻辑 */ 

11.public class UserService{ 

12.    //主动创建数据访问组件 

13.    UserDao dao = new UserDao（）;     

14.    //处理新增用户业务逻辑 

15.    public void addUser（String userName,String userPwd）{ 

16.        User user = new User（）; 

17.        user.setUserName（userName）; 

18.        user.setUserPwd（userPwd）; 

19.        //调用UserDao的saveUser方法进行数据保存 

20.        dao.saveUser（user）;      

21.    } 

22.    ......   

23.} 

24. 

25./** 负责处理用户管理业务请求 */ 

26.public class UserAction{ 

27.    //主动创建业务逻辑处理组件 

28.    UserService service = new UserService（）; 

29.    //处理新增用户请求 

30.    public void addUser（）{ 

31.        String userName = "liubin"; 

32.        String userPwd = "123456"; 

33.        //调用UserService的addUser方法进行业务逻辑处理 

34.        service.addUser（userName,userPwd）; 

35.    }    

36.    ...... 

37.} 

上面这种风格（见图6-2）的代码是那么眼熟，又是那么亲切，毕竟用了那么多年，不知是习惯了还是麻木了。

在一个类（如UserAction类）中需要用到另一个类（如UserService类），也就是一个类依赖另一个类时，顺手就是一个"new"，当应用变得庞大，依赖关系网也随之复杂，为测试与维护带来的困难呈指数上升。

那能不能做到"不请自来"呢？

答案是可以的。

想象一下，如果有一座工厂专门负责生产Bean实例的话，"new"的工作就可以交给它了，倘若还能"送货上门"的话，自然也就"不请自来"。

这就是Spring最初的动机，自Spring呱呱坠地之日起，理想变为现实，从此JavaEE应用开发步入了"不请自来"的时代。

例如：

1./** 负责处理用户管理底层数据访问 */ 

2.public class UserDao{ 

3.    //保存用户数据 

4.    public void saveUser（User user）{ 

5.        //进行数据的保存工作，省略代码 

6.    } 

7.    ......   

8.} 

9. 

10./** 负责处理用户管理业务逻辑 */ 

11.public class UserService{ 

12.    //仅声明数据访问组件的引用 

13.    UserDao dao;     

14.    //处理新增用户业务逻辑 

15.    public void addUser（String userName,String userPwd）{ 

16.        User user = new User（）; 

17.        user.setUserName（userName）; 

18.        user.setUserPwd（userPwd）; 

19.        //调用UserDao的saveUser方法进行数据保存 

20.        dao.saveUser（user）;      

21.    } 

22.    //提供一条UserDao对象的注入通道 

23.    public void setDao（UserDao dao）{ 

24.        this.dao=dao; 

25.    }    

26.    ......   

27.} 

28. 

29./** 负责生产与分发Bean的小作坊 */ 

30.public class BeanFactory{ 

31.    //生产一个数据访问组件 

32.    UserDao dao = new UserDao（）; 

33.    //再生产一个业务逻辑处理组件 

34.    UserService service = new UserService（）; 

35.    //将数据访问组件装配到业务逻辑处理组件中 

36.    service.setDao（dao）; 

37.    //分发    业务逻辑处理组件 

38.    public UserService getUserService（）{ 

39.        return  service 

40.    } 

41.} 

42. 

43./** 负责处理用户管理业务请求 */ 

44.public class UserAction{ 

45.   //实例化Bean小作坊 

46.    BeanFactory beanFactory=new BeanFactory（）; 

47.    //从Bean小作坊中取出业务逻辑处理组件实例 

48.    UserService service=beanFactory.getUserService（）; 

49.    //处理新增用户请求 

50.    public void addUser（）{ 

51.        String userName = "liubin"; 

52.        String userPwd = "123456"; 

53.        //调用UserService的addUser方法进行业务逻辑处理 

54.        service.addUser（userName,userPwd）; 

55.    } 

56.    ...... 

57.} 

上述代码中，BeanFactory是我们特意设计的一个Bean小作坊，用于生产、装配与分发Bean实例。

大家可以看到，业务控制器UserAction中从Bean小作坊取回的业务逻辑组件是已经完全装配好的成品Bean，在业务逻辑组件UserService中再也看不到往昔"new"的身影了，这种基于Bean容器的设计模式，使控制层、逻辑层及数据层实现充分解耦，如图6-3所示，可以提高可测试性与可维护性

于是很多保守与固执的"老资历"JavaEE工程师开始呐喊：

"反了！

反了！

！

"。

没错，是反了，是控制权发生了反转，应用本身不再负责依赖对象的创建及维护，依赖对象的创建及维护交由外部容器负责。

这样控制权就由应用转移到了外部容器，这种控制权的转移就是所谓的控制反转或反转控制。

所谓依赖注入就是指程序在运行期，由外部容器动态地将依赖对象注入到组件中。

这种依赖注入的过程就如同生产车间将零件装配到机器上一样，注入的过程其实就是一种装配的过程。

正是基于这种思想，Spring才推出了功能强大的Bean工厂与控制反转IoC容器，在IoC容器里通过简单地装配完成Bean实例之间的依赖注入

6.1.4 何为"面向切面编程AOP"

在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：

日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。

当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。

方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。

这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。

如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放置到某个地方集中管理，然后在具体运行时，再由容器动态织入这些共有代码的话，最起码可以解决两个问题：

JavaEE程序员在编写具体的业务逻辑处理方法时，只需关心核心的业务逻辑处理，既提高了工作效率，又使代码变更简洁优雅。

在日后的维护中由于业务逻辑代码与共有代码分开存放，而且共有代码是集中存放的，因此使维护工作变得简单轻松。

面向切面编程AOP技术就是为解决这个问题而诞生的，切面就是横切面，如图6-5所示，代表的是一个普遍存在的共有功能，例如，日志切面、权限切面及事务切面等。

下面我们以用户管理业务逻辑组件UserService的AOP实现过程（见图6-6）为例，深度剖析一下AOP技术的实现原理。

AOP技术是建立在Java语言的反射机制与动态代理机制之上的。

业务逻辑组件在运行过程中，AOP容器会动态创建一个代理对象供使用者调用，该代理对象已经按JavaEE程序员的意图将切面成功切入到目标方法的连接点上，从而使切面的功能与业务逻辑的功能同时得以执行。

从原理上讲，调用者直接调用的其实是AOP容器动态生成的代理对象，再由代理对象调用目标对象完成原始的业务逻辑处理，而代理对象则已经将切面与业务逻辑方法进行了合成。

现将图6-6中涉及到的一些概念解释如下。

切面（Aspect）：

其实就是共有功能的实现。

如日志切面、权限切面、事务切面等。

在实际应用中通常是一个存放共有功能实现的普通Java类，之所以能被AOP容器识别成切面，是在配置中指定的。

通知（Advice）：

是切面的具体实现。

以目标方法为参照点，根据放置的地方不同，可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）与环绕通知（Around）5种。

在实际应用中通常是切面类中的一个方法，具体属于哪类通知，同样是在配置中指定的。

连接点（Joinpoint）：

就是程序在运行过程中能够插入切面的地点。

例如，方法调用、异常抛出或字段修改等，但Spring只支持方法级的连接点。

切入点（Pointcut）：

用于定义通知应该切入到哪些连接点上。

不同的通知通常需要切入到不同的连接点上，这种精准的匹配是由切入点的正则表达式来定义的。

目标对象（Target）：

就是那些即将切入切面的对象，也就是那些被通知的对象。

这些对象中已经只剩下干干净净的核心业务逻辑代码了，所有的共有功能代码等待AOP容器的切入。

代理对象（Proxy）：

将通知应用到目标对象之后被动态创建的对象。

可以简单地理解为，代理对象的功能等于目标对象的核心业务逻辑功能加上共有功能。

代理对象对于使用者而言是透明的，是程序运行过程中的产物。

织入（Weaving）：

将切面应用到目标对象从而创建一个新的代理对象的过程。

这个过程可以发生在编译期、类装载期及运行期，当然不同的发生点有着不同的前提条件。

譬如发生在编译期的话，就要求有一个支持这种AOP实现的特殊编译器；发生在类装载期，就要求有一个支持AOP实现的特殊类装载器；只有发生在运行期，则可直接通过Java语言的反射机制与动态代理机制来动态实现。

6.1.6 开始Spring2.5旅程--HelloWorld6

在对Spring2.5有了一个初步的了解之后，下面我们将以Spring2.5在JavaApp中的应用SpringHelloWorld项目为例，全面演示一下Spring的基本使用步骤，请大家重点注意一下面向接口编程的实际应用及applicationContext.xml的具体配置。

（1）创建一个"JavaProject"，命名为"SpringHelloWorld"。

（2）创建一个文件夹"lib"用于存放Spring2.5框架的Jar包。

（3）将Spring2.5所需的spring-beans.jar、spring-context.jar、spring-core.jar、commons-attributes-compiler.jar、commons-attributes-api.jar、commons-logging.jar及log4j-1.2.15.jar复制到lib文件夹下，将这些Jar包加入到项目的Classpath中。

（4）创建以下几个包，用于存放项目的类或接口：

test.spring.dao包（存放数据访问接口）、test.spring.dao.impl包（存放数据访问接口实现）、test.spring.service包（存放业务逻辑接口）、test.spring.service.impl包（存放业务逻辑接口实现）、test.spring.action包（存放业务控制组件）、test.spring.bean包（存放ORM对象）、test.spring.junit包（存放Junit测试用例）。

（5）编写用户ORM类User，代码如下：

1.package test.spring.bean; 

2./** 用户持久化类 */ 

3.public class User { 

4.Integer id;//自然ID号 

5.String userName; //用户名 

6.String userPwd;//用户密码 

7.//默认构造方法 

8.public User（）{} 

9.//自定义构造方法 

10.public User（Integer id, String userName, String userPwd） { 

11.this.id = id; 

12.this.userName = userName; 

13.this.userPwd = userPwd; 

14.} 

15.//省略属性的get/set方法对 

16.} 

（6）编写数据访问接口UserDao，代码如下：

1.package test.spring.dao; 

2.import test.spring.bean.User; 

3./** 用户管理底层数据访问接口 */ 

4.public interface UserDao { 

5.//处理新增用户业务逻辑 

6.public void addUser（User user）; 

7.//处理装载用户业务逻辑 

8.public User loadUser（Integer id）; 

9.//处理修改用户业务逻辑 

10.public void modiUser（User user）; 

11.//处理删除用户业务逻辑 

12.public void delUser（Integer id）; 

13.} 

（7）编写数据访问接口实现类UserDaoImpl，代码如下：

1.package test.spring.dao.impl; 

2.import test.spring.bean.User; 

3.import test.spring.dao.UserDao; 

4./** 用户管理底层数据访问接口实现 */ 

5.public class UserDaoImpl implements UserDao { 

6.//处理新增用户业务逻辑 

7.public void addUser（User user） { 

8.//由于该实例未实现数据库访问，省略插入数据库记录的代码 

9.System.out.println（"用户名为"+user.getUserName（）+"的用户新增成功!

"）; 

10.} 

11.//处理删除用户业务逻辑 

12.public void delUser（Integer id） { 

13.//由于该实例未实现数据库访问，省略删除数据库记录的代码 

14.System.out.println（"ID号为"+id+"的用户删除成功!

"）; 

15.} 

16.//处理装载用户业务逻辑 

17.public User loadUser（Integer id） { 

18.//由于该实例未实现数据库访问,省略读取数据库记录的代码 

19.return new User（1,"liubin","123456"）; 

20.} 

21.//处理修改用户业务逻辑 

22.public void modiUser（User user） { 

23.//由于该实例未实现数据库访问，省略更新数据库记录的代码 

24.System.out.println（"ID号为"+user.getId（）+"的用户修改成功!

"）; 

25.} 

26.} 

（8）编写业务逻辑接口UserService，代码如下：

1.package test.spring.service; 

2.import test.spring.bean.User; 

3./** 用户管理业务逻辑接口 */ 

4.public interface UserService { 

5.//处理新增用户业务逻辑 

6.public void addUser（String userName,String userPwd）; 

7.//处理装载用户业务逻辑 

8.public User loadUser（Integer id）; 

9.//处理修改用户业务逻辑 

10.public void modiUser（Integer id,String userName,String userPwd）; 

11.//处理删除用户业务逻辑 

12.public void delUser（Integer id）; 

13.} 

（9）编写业务逻辑接口实现类UserServiceImpl，代码如下：

1.package test.spring.service.impl; 

2.import test.spring.bean.User; 

3.import test.spring.dao.UserDao; 

4.import test.spring.service.UserService; 

5./** 用户管理业务逻辑接口实现 */ 

6.public class UserServiceImpl implements UserService { 

7.//仅声明数据访问组件的引用 

8.UserDao dao; 

9.//处理新增用户业务逻辑 

10.public void addUser（String userName, String userPwd） { 

11.User user = new User（）; 

12.user.setUserName（userName）; 

13.user.setUserPwd（userPwd）; 

14.dao.addUser（user）; 

15.} 

16.//处理删除用户业务逻辑 

17.public void delUser（Integer id） { 

18.dao.delUser（id）; 

19.} 

20.//处理装载用户业务逻辑 

21.public User loadUser（Integer id） { 

22.return dao.loadUser（id）; 

23.} 

24.//处理修改用户业务逻辑 

25.public void modiUser（Integer id, String userName, String userPwd） { 

26.User user = dao.loadUser（id）; 

27.user.setUserName（userName）; 

28.user.setUserPwd（userPwd）; 

29.dao.modiUser（user）; 

30.} 

31.//提供一条UserDao对象的注入通道 

32.public void setDao（UserDao dao）{ 

33.this.dao=dao; 

34.} 

35.} 

（10）编写业务控制器UserAction，代码如下：

1.package test.spring.action; 

2.import test.spring.bean.User; 

3.import test.spring.service.UserService; 

4./** 用户管理业务控制器 */ 

5.public class UserAction { 

6.//仅声明业务逻辑组件的引用 

7.UserService service; 

8.//处理新增用户请求 

9.public void addUser（） { 

10.String userName="liubin"; 

11.String userPwd="123456"; 

12.service.addUser（userName,userPwd）; 

13.} 

14.//处理删除用户请求 

15.public void delUser（） { 

16.service.delUser

（1）; 

17.} 

18.//处理装载用户请求 

19.public void loadUser（） {