SSH 从入门到"放弃"--Spring（1）

流川枫

发布于 2018-09-12 10:53:48

3710

发布于 2018-09-12 10:53:48

文章被收录于专栏：AI星球

Spring 的世界

1. Spring简介：

Spring是一个开源的框架，是为了解决企业应用开发的复杂性而创建的，Spring致力于 Java EE应用的各层的解决方案，而不是专注于某一层的方案，它贯穿于表现层、业务层、持久层，与其它已有的框架无缝整合。

-** 爱上Spring的理由？**

面向接口编程，不重复造轮子：将接口与实现进行分离，一个接口根据不同的个性化需求可以产生许多不同的实现。大大降低了组件之间的耦合程度，提高了组件的可测试行与相对独立性。
基于工厂模式的IoC容器：将传统Java EE中的对象【eg. User user = new User（）】，全部交由Spring的Bean工厂进行生产、装配、生命周期的管理。
面向切面的编程：将业务逻辑中重复的一些功能模块【eg. 日志输出、事务管理、权限控制等】代码全部抽取出来，集中放置到某个地方，使得Java EE程序员先只需要关注真正的业务逻辑的处理，大大提高效率，最后在具体的运行时，再由Spring的AOP模块自动完成重组，使得业务逻辑代码与共有的功能模块代码完美的复合。
与Hibernate 、Struts2等框架无风对接。

补充：

数据访问层DAO（Database Access Object）：数据访问接口，使用DAO是为了实现业务逻辑层与数据控制层的分离。
对象持久化模块ORM：一般与其他ORM框架结合【eg.Hibernate】。

1.1Spring的拿手好戏——控制反转与依赖注入

1.1.1传统的业务控制层、业务逻辑层、数据访问层之间的依赖关系：

传统代码结构：

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

public class UserDao {
//  保存用户数据
    public void saveUser(User user){
        ....
    }
}

//2.存储用户基本字段的Bean层

public class User(){
    private String userName;
    private String userPwd;
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public String getUserPwd() {
        return userPwd;
    }
    
}


//3.负责处理用户请求的业务逻辑层

public class UserService(){
//  主动创建数据访问组件
    UserDao dao = new UserDao();
//  处理新增用户的业务逻辑
    public void addUser( String userName,String userPwd){
//      主动创建Bean层的对象
        User user = new User();
        user.setUserName(userName);
        user.setUserPwd(userPwd);
//      调用UserDao的saveUser()方法进行数据的保存
        dao.saveUser(user)
    }
}


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

public class UserAction(){
//  主动创建业务逻辑层处理组件
    UserService service = new UserService();
    public void addUser(){
        String userName="流川枫";
        String userPwd="123321"；
//      调用UserService的addUser()的方法
        service.addUser(userName,userPwd){
            
            .....
        }
    }
}

上面的这种代码风格，看起来是那么的熟悉和亲切。在一个类（UserAction）中需要用到另一个类（UserService），也就是一个类依赖于另一个类，顺手就是一个new( )，主动创建所需的依赖关系，看起来很方便，但是当应用变得十分大的时候，这种依赖关系就会变得很复杂，后期的维护变得十分困难。

传统业务控制层、业务逻辑层、数据访问层之间的依赖关系

那么问题来了，我们可不可以有一个工厂专门负责生产Bean实例，不用我们主动的使用 new 去创建所需的依赖关系，主动送货上门，答案是肯定的，因为这就是设计Spring的初衷。有工厂模式的代码结构：

//1.负责处理用户数据管理的数据访问层
public class UserDao {
//  保存用户数据
    public void saveUser(User user){
        ....
    }
}

//2.存储用户基本字段的Bean层
public class User(){
    private String userName;
    private String userPwd;
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public String getUserPwd() {
        return userPwd;
    }
    
}


//3.负责处理用户请求的业务逻辑层
public class UserService(){
//  仅声明数据访问组件的引用
    UserDao dao;
//  处理新增用户的业务逻辑
    public void addUser( String userName,String userPwd){
//      主动创建Bean层的对象
        User user = new User();
        user.setUserName(userName);
        user.setUserPwd(userPwd);
//      调用UserDao的saveUser()方法进行数据的保存
        dao.saveUser(user);
    }
    //提供一条UserDao对象注入的通道
    public void setDao(UserDao dao){
        this.dao=dao;
    }
}

//4.负责生产与分发Bean的小作坊
public class BeanFactory(){
//  生产一个数据访问组件
    UserDao dao = new UserDao();
//  生产一个业务逻辑处理组件
    UserService service =  new UserService();
//  将数据访问组件装配到业务逻辑处理组件中
    service.setDao(dao);
//  分发业务逻辑处理组件
    public UserService getUserService(){
        return service;
    }
}


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

public class UserAction(){
//  实例化Bean小小作坊
    BeanFactory beanFactory = new BeanFactroy();
//  从Bean小作坊中取出业务逻辑层处理组件实例
    UserService service = beanFactory.getUserService();
//  处理新增用户的请求
    
    public void addUser(){
        String userName="流川枫";
        String userPwd="123321"；
//      调用UserService的addUser()的方法
        service.addUser(userName,userPwd){
            
            .....
        }
    }
}

上述代码中，我们创建了一个Bean小作坊，专门用于生产、装配与分发Bean实例。分析上面的伪代码可知：

业务控制器UserAction中从Bean小作坊取回的业务逻辑组件是已经完全装配好的成品Bean，在业务逻辑组件UserService中再也看不到new的身影，这种基于Bean工厂的设计模式，使得控制层、逻辑层、数据层实现了充分的解耦合。

与传统的Java EE开发代码可以看到，是控制权发生了反转，应用本身不再负责依赖对象的创建，这样的控制权就由应用转移到外部容器，这种控制权的转移就是所谓的控制权反转（反转控制）。所谓依赖注入就是指程序在运行期，由外部容器动态的将依赖的对象注入到组件中，这种依赖注入的过程就如同生产车间将零件装配到机器上一样，注入的过程就是一种装配的过程。

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

至于Spring的面向切面的特性以及后续的Spring深入，在下一篇再介绍吧！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2016.05.21 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度