Spring框架入门（一）

spring概述

• spring是什么

  • spring是分层的java se/ee应用full-stack轻量级框架，以ioc(inverse of control,反转控制)和aop(aspect oriented programming,面向切面编程)为内核，提供了展现层spring mvc和持久层spring jdbc以及业务层事务管理等众多的企业版应用技术，还能整合开源世界众多著名的第三方框架和类库逐渐成为使用最多的java ee企业应用开源框架。

• spring优势

  • 方便解耦，简化开发

    • 通过spring提供的ioc容器，可以将对象间的依赖关系交由spring进行控制，避免硬编码所造成的过度程序耦合，用户也不必再为单例模型类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用

  • aop编程的支持

    • 通过spring的aop功能，方便进行面向切面的编程，许多不容易用传统oop实现的功能可以通过aop轻松应付

  • 声明式事务的支持

    • 可以将我们从单词烦闷的事务管理代码中解脱出来，通过声明方式灵活的进行事务管理，提高开发效率和质量

  • 方便程序的测试

    • 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作而是随手可做的事情

  • 方便集成各种优秀框架

    • spring可以降低各种框架的使用难度，提供了各种优势框架的直接支持

  • 降低javaee api的使用难度

    • spring对javaee api（如jdbc）进行了薄薄的封装层，使这些api的使用难度大大降低。

  • java源码经典学习案例

spring简单案例降低耦合方式

• 建立一个高耦合的案例（模拟用户保存）原因：当前类new一个另外的类的对象

  • 用户业务接口代码userservice.java

    package com.mypro.service;
    ​
    /**
     * 用户业务接口
     */
    public interface userservice {
        /**
         * 模拟保存用户
         */
        void saveuser();
    }​

  • 用户的业务实现类代码userserviceimpl.java

    package com.mypro.service.impl;
    ​
    import com.mypro.dao.userdao;
    import com.mypro.dao.impl.userdaoimpl;
    import com.mypro.service.userservice;
    ​
    /**
     * 用户的业务实现类
     */
    public class userserviceimpl implements userservice {
        //高耦合原因之一
        private userdao userdao = new userdaoimpl();
    ​
        @override
        public void saveuser() {
            userdao.saveuser();
        }
    }

  • 用户的持久层接口代码userdao.java

    package com.mypro.dao;
    ​
    /**
     * 用户的持久层接口
     */
    public interface userdao {
        /**
         * 模拟保存用户保存的接口
         */
        void saveuser();
    }​

  • 用户的持久层实现类代码userdaoimpl.java

    package com.mypro.dao.impl;
    ​
    import com.mypro.dao.userdao;
    ​
    /**
     * 用户的持久层实现类
     */
    public class userdaoimpl implements userdao {
        @override
        public void saveuser() {
            system.out.println("用户保存成功！");
        }
    }

  • 主类代码client.java

    package com.mypro.ui;
    ​
    import com.mypro.service.userservice;
    import com.mypro.service.impl.userserviceimpl;
    ​
    /**
     * 模拟一个表现层，用于调用业务层
     */
    public class client {
        public static void main(string[] args) {
            //高耦合原因之二
            userservice userservice = new userserviceimpl();
            userservice.saveuser();
        }
    }

• 第一次优化上述代码，就是将两个出现new对象的耦合原因解决。解决方式如下：

  • 需要一个配置文件来配置我们的service和dao的对象，配置的内容：唯一标识=全限定类名（key=value）

  • 通过读取配置文件中配置的内容，反射创建对象。建议使用properties文件，也可以用xml文件，后者读取比较麻烦。文件名为bean.properties

    userservice=com.mypro.service.impl.userserviceimpl
    userdao=com.mypro.dao.impl.userdaoimpl

  • 定义一个中间类专门获取properties文件的内容（service和dao的对象）

    package com.mypro.factory;
    ​
    import java.io.inputstream;
    import java.util.enumeration;
    import java.util.hashmap;
    import java.util.map;
    import java.util.properties;
    ​
    /**
     * 一个创建bean对象的工厂
     */
    public class beanfactory {
        //定义一个properties对象
        private static properties properties;
    ​
        //使用静态代码块为properties对象赋值
        static{
            try{
                //实例化对象
                properties = new properties();
                //获取properties文件的流对象
                inputstream in = beanfactory.class.getclassloader().getresourceasstream("bean.properties");
                properties.load(in);
                }
            }catch(exception e){
                throw new exceptionininitializererror("初始化properties文件失败！");
            }
        }
    ​
        /**
         * 根据bean的名称获取bean对象
         * @param beanname
         * @return
         */
        public static object getbean(string beanname){
            object bean = null;
            try{
                string beanpath = properties.getproperty(beanname);
                //newinstance()   每次都会调用默认构造函数创建对象
                bean = class.forname(beanpath).newinstance();
            }catch(exception e){
                e.printstacktrace();
            }
            return bean;
        }
    }

  • 修改出现耦合原因的代码

    //ui包下的client主类
    userservice userservice = beanfactory.getbean("userservice");
    //service包下的userserviceimpl的类
    userdao userdao = beanfactory.getbean("userdao");

• 第二次优化代码：在第一次优化代码的基础上再次优化。原因：第一次的代码是多例模式的工厂模式，因为在beanfactory类的getbean方法中出现了newinstance()方法，这个方法是每次都会默认调用构造方法，以至于创建的每个对象是不同的。一旦执行多次保存用户的方法，就会浪费空间。解决方式：使用单例模式的工厂模式

  • 只需创建一个用于存放我们要创建的对象的map集合，我们称之为容器。

    package com.mypro.factory;
    ​
    import java.io.inputstream;
    import java.util.enumeration;
    import java.util.hashmap;
    import java.util.map;
    import java.util.properties;
    ​
    /**
     * 一个创建bean对象的工厂
     *
     * bean：在计算机英语中，由可重用组件的含义
     * javabean：就是创建我们的service和dao的对象
     *  javabean 不等于 实体类，而是远大于的
     *
     *      第一、需要一个配置文件来配置我们的service和dao的
     *           配置的内容：唯一标识=全限定类名（key=value）
     *      第二、通过读取配置文件中配置的内容，反射创建对象
     *           建议使用properties文件，xml文件也可以，不过读取比较麻烦
     */
    public class beanfactory {
        //定义一个properties对象
        private static properties properties;
    ​
        //创建一个用于存放我们要创建的对象的map容器
        private static map<string, object> beans;
    ​
        //使用静态代码块为properties对象赋值
        static{
            try{
                //实例化对象
                properties = new properties();
                //获取properties文件的流对象
                inputstream in = beanfactory.class.getclassloader().getresourceasstream("bean.properties");
                properties.load(in);
    ​
                //实例化容器
                beans = new hashmap<string, object>();
                //取出配置文件中所有的key
                enumeration keys = properties.keys();
                //遍历枚举
                while(keys.hasmoreelements()){
                    //取出每个key
                    string key = keys.nextelement().tostring();
                    //根据key获取value
                    string beanpath = properties.getproperty(key);
                    //反射创建对象
                    object value = class.forname(beanpath).newinstance();
                    //把key和value存入容器中
                    beans.put(key, value);
                }
            }catch(exception e){
                throw new exceptionininitializererror("初始化properties文件失败！");
            }
        }
    ​
        /**
         * 根据bean的名称获取bean对象
         * @param beanname
         * @return
         */
        public static object getbean(string beanname){
            bean = beans.get(beanname);
            return bean;
        }
    }