1   Java培训实战教程之自定义spring

1.1   描述

       在企业级开发中，spring框架应用非常广。为了让已经学习过spring框架同学，可以更深入的理解和应用spring，本文将通过自定义spring，更佳系统的阐述spring核心：IoC、AOP。
       IoC（Inversion of Control）控制反转：将对象的创建权交与spring框架，及将创建权反转给spring框架。IoC主要解决计算机程序的耦合问题。
       AOP（Aspect Oriented Programming）面向切面编程：通过运行期动态代理实现程序功能的统一维护的一种技术。
 

1.2   分析

l  如果要实现自定义spring，可以将器拆分成多个功能实现。
l  阶段一：编写配置文件，服务器tomcat启动时，加载配置文件
l  阶段二：使用Jsoup解析xml，并封装到指定的JavaBean中
l  阶段三：编写工厂类用于创建指定bean，并完成property注入
l  阶段四：使用@Transactional进行事务管理
 

1.3   搭建环境

1.3.1   javabean

public class User {      private Integer uid;    private String username;    private String password;

 

1.3.2    dao

public interface UserDao {    /**     * 保存     * @param user     */    public void save(User user);   }

public class UserDaoImpl implements UserDao {      @Override    public void save(User user) {       //TODO 暂时只打印       System.out.println(user);    }   }

 

1.3.3   service

public interface UserService {    /**     * 注册     * @param user     */    public void register(User user); }

public class UserServiceImpl implements UserService {      private UserDao userDao;    public void setUserDao(UserDao userDao) {       this.userDao = userDao;    }       @Override    public void register(User user) {       this.userDao.save(user);    } }

 

1.4   阶段一：编写配置文件，服务器启动加载

1.4.1   xml配置文件

l  在src下添加“applicationContext.xml”，并将dao和service配置到xml文件中。
l  使用<bean>标签配置一个实现类
       class：    配置实现类的全限定名称
       id： 进行唯一命名，用于提供给程序获得
l  使用<property>配置javabean属性的注入
       name：   配置的service的属性名
       ref：       配置其他bean对象的引用

<?xml version="1.0" encoding="UTF-8"?> <beans>     <!-- dao -->     <bean id="userDaoId" class="cn.itcast.demo.dao.impl.UserDaoImpl"></bean>     <!-- service -->     <bean id="userServiceId" class="cn.itcast.demo.service.impl.UserServiceImpl">         <property name="userDao" ref="userDaoId"></property>     </bean> </beans>

 

1.4.2   加载配置文件

l  tomcat启动时，加载配置文件方式总结：
       1.编写Servlet，配置servlet，并添加<load-on-startup>，在init(ServletConfig)初始化方式中加载。
       2.编写Filter，配置filter，在init(FilterConfig)初始化方法中加载
       3.编写Listener，实现接口ServletContext，配置listener，在contextInitialized(ServletContextEvent sce)方法中加载。
l  spring采用listener方案
       1.提供实现类ContextLoaderListener
       2.编写全局初始化参数contextConfigLocation，用于确定xml位置
              <param-value>classpath:applicationContext.xml</param-value> 加载类路径下的xml文件
        <param-value>applicationContext.xml</param-value> 加载WEB-INF目录的配置文件
 
l  xml配置

<!-- 确定xml位置 -->     <context-param>         <param-name>contextConfigLocation</param-name>         <param-value>classpath:applicationContext.xml</param-value>     </context-param>         <!-- 配置监听器 -->     <listener>         <listener-class>cn.itcast.myspring.listener.ContextLoaderListener</listener-class>     </listener>

 
l  实现类

public class ContextLoaderListener implements ServletContextListener {       @Override     public void contextInitialized(ServletContextEvent sce) {         // 0 获得ServletContext对象应用         ServletContext context = sce.getServletContext();         // 1 加载配置         String config = context.getInitParameter("contextConfigLocation");         if(config == null){ //默认配置文件位置             config= "applicationContext.xml";         }                 InputStream xmlIs = null;         // 2  处理路径不同情况         // * classpath:applicationContext.xml --> 表示 src/applicationContext.xml         // * applicationContext.xml --> 表示 /WEB-INF/applicationContext.xml         if (config.startsWith("classpath:")) { // 2.1 加载 类路径 （classpath、src）下的xml             xmlIs = ContextLoaderListener.class.getClassLoader().getResourceAsStream(config.substring("classpath:".length()));         } else { //2.2 加载/WEB-INF/目录下的资源             xmlIs = context.getResourceAsStream("/WEB-INF/" + config);         }         //2.3 配置文件必须存在，否则抛异常         if(xmlIs == null){             throw new RuntimeException("资源文件["+config+"]没有找到");         }                 //TODO 3 解析配置         if (xmlIs != null) {             System.out.println(xmlIs);         }     }     @Override     public void contextDestroyed(ServletContextEvent sce) {     } }

 

1.5   阶段二：解析xml，并封装到指定javabean中

1.提供Property类，用于封装<property name=" " ref=" "></property>
2.提供Bean类，用于封装<bean id=" " class=" ">
       一个<bean> 标签体中可以配置多个<property>需要一个容器存放，没有顺序要求，且不能重复，选择Set
3.提供BeanFactory类，并在类同提供容器存放多个Bean 类，为了方便获取使用Map。

1.5.1    property javabean

/**  * 用于封装 <property name="userDao" ref="userDaoId"></property>  */ public class Property {       //属性名称    private String name;    //另一个bean引用名    private String ref;       public Property(String name, String ref) {       super();       this.name = name;       this.ref = ref;    }

 

1.5.2    bean  javabean

public class Bean {      //bean名称    private String beanId;    //bean的实现类    private String beanClass;    //取值：singleton 单例，prototype 原型(多例)【扩展】    private String beanType;          //所有的property    private Set<Property> propSet = new HashSet<Property>();       public Bean(String beanId, String beanClass) {       super();       this.beanId = beanId;       this.beanClass = beanClass;    }

 

1.5.3    BeanFactory 工厂模式类

public class BeanFactory {         //////////////////工厂模式////////////////////////     private static BeanFactory factory = new BeanFactory();     private BeanFactory(){     }       /**      * 获得工厂实例      * @author lt      * @return      */     public static BeanFactory getInstance() {         return factory;     }

 

1.5.4    BeanFactory 提供Map 缓存

//////////////////缓存所有的Bean/////////////////////////////////     //bean数据缓存集合 ，key:bean名称 ，value:bean封装对象     private static Map<String, Bean> beanData;// = new HashMap<String, String>();     static{         // 从配置文件中获得相应的数据 1.properties 2.xml         //beanData.put("userDao", "com.itheima.ebs.service.impl.BusinessServiceImpl");     }         public static void setBeanData(Map<String, Bean> beanData) {         BeanFactory.beanData = beanData;     }

 

1.5.5    修改Listener解析xml

l  使用Jsoup解析，导入jar包  
l  修改contextInitialized 方法

//TODO 3 解析配置       if (xmlIs != null) {          //3.1解析          Map<String, Bean> data = parserBeanXml(xmlIs);          //3.2 将解析结果放置到工厂中          BeanFactory.setBeanData(data);       }

 
l  解析方法parserBeanXml(InputStream)

/**     * 将数据解析成bean     * @param xmlIs     * @return     */    public static Map<String, Bean> parserBeanXml(InputStream xmlIs) {       try {          //0提供缓冲区域          Map<String, Bean> data = new HashMap<String, Bean>();                            //1解析文件，并获得Document          Document document = Jsoup.parse(xmlIs, "UTF-8", "");                   //2 获得所有的bean元素          Elements allBeanElement = document.getElementsByTag("bean");                   //3遍历          for (Element beanElement : allBeanElement) {             //5 将解析的结果封装到bean中             // 5.1 bean名称             String beanId = beanElement.attr("id");             // 5.2 bean实现类             String beanClass = beanElement.attr("class");                         // 5.3 封装到Bean对象             Bean bean = new Bean(beanId,beanClass);                         // 6 获得所有的子元素 property             Elements allPropertyElement = beanElement.children();             for (Element propertyElement : allPropertyElement) {                 String propName = propertyElement.attr("name");                 String propRef = propertyElement.attr("ref");                 Property property = new Property(propName, propRef);                                // 6.1 将属性追加到bean中                 bean.getPropSet().add(property);             }                         data.put(beanId, bean);          }          return data;       } catch (Exception e) {          throw new RuntimeException(e);       }    }

 

1.6   阶段三：完善BeanFactory获得实例

l  使用 BeanUtils.setProperty 设置数据，需要导入jar包 l  BeanFactory 提供 getBean方法

////////////////获得Bean实例///////////////////////////////////     public Object getBean(String beanId) {                 try {             // 通过bean 的名称获得具体实现类             Bean bean = beanData.get(beanId);             if(bean ==null) return null;             String beanClass = bean.getBeanClass();             Class clazz = Class.forName(beanClass);             Object beanObj = clazz.newInstance();             //DI 依赖注入，将在配置文件中设置的内容，通过bean的set方法设置到bean实例中             Set<Property> props = bean.getPropSet();             for (Property property : props) {                 String propName = property.getName();                 String propRef = property.getRef(); //另一个javabean，需要重容器中获得                 Object propRefObj = getBean(propRef);                 //PropertyDescriptor pd = new PropertyDescriptor(propName, clazz);                 //pd.getWriteMethod().invoke(bean, propRefObj);                 BeanUtils.setProperty(beanObj, propName, propRefObj);             }                         return beanObj;         } catch (Exception e) {             throw new RuntimeException(e);         }     }

 
l  测试

//测试 UserService userService = (UserService) BeanFactory.getInstance().getBean("userServiceId"); userService.register(null);

 
 

1.7   阶段四：spring事务管理

 

1.7.1   修改自定义spring

l  提供JdbcUtils工具类，用于在当前线程中共享Connection
l  提供@Transaction 用于标记那些类需要进行事务管理
   

1.7.1.1         JdbcUtils工具类

l  使用ThreadLocal 保存Connection，在当前线程中共享Connection
l  并提供提交和回滚方法，自动关闭连接

public class JdbcUtils {         private static ThreadLocal<Connection> local = new ThreadLocal<Connection>();         static{         try {             //注册驱动             Class.forName("com.mysql.jdbc.Driver");         } catch (Exception e) {             throw new RuntimeException(e);         }     }     /**      * 获得连接      * @return      */     public static Connection getConnection(){         try {             Connection conn = local.get();             if (conn == null) {                 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2", "root", "1234");                 local.set(conn);             }             return conn;         } catch (Exception e) {             throw new RuntimeException(e);         }     }     /**      * 提交事务      */     public static void commit() {         Connection conn = getConnection();         DbUtils.commitAndCloseQuietly(conn);     }       /**      * 回滚事务      */     public static void rollback() {         Connection conn = getConnection();         DbUtils.rollbackAndCloseQuietly(conn);     }   }

 

1.7.1.2         @Transactional

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Transactional {   }

 

1.7.1.3         修改BeanFactory

l  通过getBean 获得对象实例时，如果对象有@Transactional注解，将返回代理对象，对目标对象上所有的方法都进行事务管理。
l  如果没有异常提交事务，并关闭连接
l  如果有异常回滚事务，并关闭连接
 

public Object getBean(String beanId) {                 try {             // 通过bean 的名称获得具体实现类             Bean bean = beanData.get(beanId);             if(bean ==null) return null;             String beanClass = bean.getBeanClass();             Class<?> clazz = Class.forName(beanClass);             Object beanObj = clazz.newInstance();             //DI 依赖注入，将在配置文件中设置的内容，通过bean的set方法设置到bean实例中             Set<Property> props = bean.getPropSet();             for (Property property : props) {                 String propName = property.getName();                 String propRef = property.getRef(); //另一个javabean，需要重容器中获得                 Object propRefObj = getBean(propRef);                 //PropertyDescriptor pd = new PropertyDescriptor(propName, clazz);                 //pd.getWriteMethod().invoke(bean, propRefObj);                 BeanUtils.setProperty(beanObj, propName, propRefObj);             }                         //如果类上有注解返回代理对象             if(clazz.isAnnotationPresent(Transactional.class)){                 final Object _beanObj = beanObj;                 return Proxy.newProxyInstance(                         clazz.getClassLoader(),                         clazz.getInterfaces(),                         new InvocationHandler() {                             @Override                             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                                 try {                                     //开启事务                                     JdbcUtils.getConnection().setAutoCommit(false);                                                                         //执行目标方法                                     Object obj = method.invoke(_beanObj, args);                                                                         //提交事务                                     JdbcUtils.commit();                                                                         return obj;                                                                     } catch (Exception e) {                                     //回顾事务                                     JdbcUtils.rollback();                                     throw new RuntimeException(e);                                 }                             }                         });             }                         return beanObj;         } catch (Exception e) {             throw new RuntimeException(e);         }     }

 
 

1.7.2   初始化数据库

create table account(   id int primary key auto_increment,   username varchar(50),   money int ); insert into account(username,money) values('jack','10000'); insert into account(username,money) values('rose','10000');

 

1.7.3   dao层

l  必须使用自定义spring提供的JdbcUtils获得连接，从而保证当前线程使用的是同一个线程。
l  通过xml配置文件创建QueryRunner实例，并注入给dao
l  扩展：如果将QueryRunner和JdbcUtils都省略，需要自己实现JdbcTemplate完成。
 

public class AccountDaoImpl implements AccountDao {         private QueryRunner runner;     public void setRunner(QueryRunner runner) {         this.runner = runner;     }       @Override     public void out(String outer, Integer money) {         try {             Connection conn = JdbcUtils.getConnection();             runner.update(conn, "update account set money = money - ? where username = ?", money, outer);         } catch (Exception e) {             throw new RuntimeException(e);         }     }       @Override     public void in(String inner, Integer money) {         try {             Connection conn = JdbcUtils.getConnection();             runner.update(conn, "update account set money = money + ? where username = ?", money,inner);         } catch (Exception e) {             throw new RuntimeException(e);         }     }   }

 

1.7.4   service层

l  在实现类上添加注解
 

@Transactional public class AccountServiceImpl implements AccountService {       private AccountDao accountDao;     public void setAccountDao(AccountDao accountDao) {         this.accountDao = accountDao;     }     @Override     public void transfer(String outer, String inner, Integer money) {         accountDao.out(outer, money);         //断电 //      int i = 1/0;         accountDao.in(inner, money);     }   }

 

1.7.5   编写spring配置

<!-- 创建queryRunner -->     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner"></bean>         <bean id="accountDao" class="cn.itcast.dao.impl.AccountDaoImpl">         <property name="runner" ref="runner"></property>     </bean>     <!-- service -->     <bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">         <property name="accountDao" ref="accountDao"></property>     </bean>

 

1.7.6   编写servlet测试

l  通过请求servlet，进行转账，此处使用固定值进行测试

public class AccountServlet extends HttpServlet {       public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {         AccountService accountService = (AccountService) BeanFactory.getInstance().getBean("accountService");         accountService.transfer("jack", "rose", 100);     }

 
 
本文版权归传智播客Java培训学院所有，欢迎转载，转载请注明作者出处。谢谢！