95992828九五至尊2

Spring结合马士兵录制的上学经验882828九五至尊手机版,IOC的回顾完成

四月 17th, 2019  |  882828九五至尊手机版

相似包罗以下多少个类:

总结的说,Spring便是经过工厂+反射将我们的bean放到它的器皿中的,当大家想用有个别bean的时候,只须求调用getBean(“beanID”)方法就能够。

模型(使用的重点目的,比如在用户管理种类中)

 

User 用户模型

规律简单表达:

Dao 连接数据库的接口类

 

Daoimpl 连接数据库实体类,比如mysql还有sqlserver分别有本身的Daoimpl

Spring容器的原理,其实便是经过解析xml文件,通过反射创建出我们所供给的bean,再将那一个bean挨个放到集合中,然后对外提供二个getBean()方法,以便大家获得那bean。

Userservice 用户服务类 用于将调用Daoimpl类将数据存款和储蓄到数据库中

 

 

上面大家来归纳完结一个demo

个中spring正是为着落到实处 Userservice 还有 Daoimpl的布帆无恙。

 

在spring的配置文件beans.xml中

beans.xml

<beans>

 

         <bean id=”u” class=”com.sisi.dao.impl.UserDAOImpl” />

[html] view
plain
 copy

        

 

         <bean
id=”userService” class=”com.sisi.service.UserService” >

 print?

                   <property
name=”userDAO” bean=”u”/>

  1. <?xml version=”1.0″ encoding=”UTF-8″?>  
  2. <beans>    
  3.     <bean id=”user” class=”com.yyb.model.User” />    
  4.     <bean id=”userDAO” class=”com.yyb.dao.impl.UserDAOImpl” />    
  5.     <bean id=”userService” class=”com.yyb.service.UserService”>    
  6.         <property name=”userDAO” bean=”userDAO” />    
  7.     </bean>    
  8. </beans>   

         </bean>

 

        

BeanFactory

</beans>

 

罗曼蒂克部分就是在应用进程中平素用fctory读取到的有关userservice的布署,结合实际应用中的

[java] view
plain
 copy

UserService service =(UserService)factory.getBean(“userService”);

 

平昔初叶化service而不用再去new二个了,同时使用上述粉青部分将DAOimpl注入userservice就一定于在userservice中之内定add方法中现实贯彻的userDAO的实体类(impl)从而完成基于布置文件使得调用的落到实处类分裂,也正是存入分化的数据库。那里有一个要害的概念

 print?

修改配置文件什么人都能改改,不过不能够轻松修改代码。配置文件就约等于三个身处个中的txt把有关消息保存在里面,用的时候就去调取,想要修改系统作为的时候就去修改它,而不是去修改系统之中代码。

  1. public interface BeanFactory {  
  2.   
  3.      Object getBean(String name);    
  4. }  

 

ClassPathXmlApplicationContext:读取xml文件内容,并创立对象及对象关联(使用setter情势)

 

[java] view
plain
 copy

 

 print?

  1. package com.yyb.spring;  
  2. import java.io.IOException;  
  3. import java.lang.reflect.InvocationTargetException;  
  4. import java.lang.reflect.Method;  
  5. import java.util.HashMap;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8.   
  9. 882828九五至尊手机版,import org.jdom.Document;  
  10. import org.jdom.Element;  
  11. import org.jdom.JDOMException;  
  12. import org.jdom.input.SAXBuilder;  
  13. public class ClassPathXmlApplicationContext implements BeanFactory  
  14. {  
  15.     private Map<String, Object> beans = new HashMap<String, Object>();  
  16.     public ClassPathXmlApplicationContext() throws JDOMException, IOException,  
  17.             InstantiationException, IllegalAccessException,  
  18.             ClassNotFoundException, SecurityException, NoSuchMethodException,  
  19.             IllegalArgumentException, InvocationTargetException  
  20.     {  
  21.         SAXBuilder sb = new SAXBuilder();  
  22.         // 构造文书档案对象  
  23.         Document doc = sb.build(ClassPathXmlApplicationContext.class  
  24.                 .getClassLoader().getResourceAsStream(“beans.xml”));  
  25.         // 获取根成分  
  26.         Element root = doc.getRootElement();  
  27.         // 取到根成分全数因素  
  28.         List list = root.getChildren();  
  29.           
  30.         for (int i = 0; i < list.size(); i++)  
  31.         {  
  32.             Element element = (Element) list.get(i);  
  33.             // 取id子元素  
  34.             String beanid = element.getAttributeValue(“id”);  
  35.             // 取class子元素  
  36.             String clzss = element.getAttributeValue(“class”);  
  37.             // 实例化  
  38.             Object o = Class.forName(clzss).newInstance();  
  39.             // 将所有bean放入map中  
  40.             beans.put(beanid, o);  
  41.             // 获取property 举办注重注入  
  42.             for (Element propertyElement : (List<Element>) element  
  43.                     .getChildren(“property”))  
  44.             {  
  45.                 String name = propertyElement.getAttributeValue(“name”);  
  46.                 System.out.println(name);//userDAO  
  47.                 String bean = propertyElement.getAttributeValue(“bean”);  
  48.                 System.out.println(bean);//userDAO  
  49.                 // 从beans.xml中依据id取到类的目的  
  50.                 //Object beanObj = this.getBean(name);  
  51.                 // 从beans.xml中根据id取到类的对象  
  52.                 Object beanObj = this.getBean(bean);  
  53.                 System.out.println(beanObj);//com.yyb.dao.impl.UserDAOImpl@a09ee92  
  54.                 // 形成setXXX方法名  
  55.                 String methodName = “set” + name.substring(0, 1).toUpperCase()  
  56.                         + name.substring(1);  
  57.                 System.out.println(name.substring(0, 1).toUpperCase());//U  
  58.                 System.out.println(name.substring(1));//serDAO  
  59.                 System.out.println(methodName);//setUserDAO  
  60.                   
  61.                 // 反射机制对艺术开始展览调用,将对象在加载bean时就注入到环境上下文中  
  62.                 Method m = o.getClass().getMethod(methodName,  
  63.                         beanObj.getClass().getInterfaces()[0]);  
  64.                 System.out.println(o.getClass());//class com.yyb.service.UserService  
  65.                 System.out.println(beanObj.getClass().getInterfaces()[0]);//interface com.yyb.dao.UserDAO  
  66.                 System.out.println(m);//public void com.yyb.service.UserService.setUserDAO(com.yyb.dao.UserDAO)  
  67.                 // 奉行注入,约等于实践了二个setXXX(args..)的艺术  
  68.                 m.invoke(o, beanObj);  
  69.             }  
  70.         }  
  71.     }  
  72.     @Override  
  73.     public Object getBean(String name)  
  74.     {  
  75.         return beans.get(name);  
  76.     }  
  77. }  

 

 

 

对于以上那段代码完结的效用为:

 

Service service=(Service)beans.get(“userService”);

Dao dao = (Dao)beans.get(“userDAO”);

//注重注入,Service达成正视dao的兑现

service.setDao(dao);

 

User:实体类

 

[java] view
plain
 copy

 

 print?

  1. public class User {  
  2.   
  3.     private String userName;    
  4.     private String password;    
  5.     /**  
  6.      * @return the userName  
  7.      */    
  8.     public String getUserName()    
  9.     {    
  10.         return userName;    
  11.     }    
  12.     /**  
  13.      * @param userName  
  14.      *            the userName to set  
  15.      */    
  16.     public void setUserName(String userName)    
  17.     {    
  18.         this.userName = userName;    
  19.     }    
  20.     /**  
  21.      * @return the password  
  22.      */    
  23.     public String getPassword()    
  24.     {    
  25.         return password;    
  26.     }    
  27.     /**  
  28.      * @param password  
  29.      *  the password to set  
  30.      */    
  31.     public void setPassword(String password)    
  32.     {    
  33.         this.password = password;    
  34.     }    
  35.     public String toString()    
  36.     {    
  37.         StringBuffer sb = new StringBuffer();    
  38.         sb.append(this.userName);    
  39.         sb.append(this.password);    
  40.         return sb.toString();    
  41.     }    
  42. }  

 

 

UserDAO

 

[java] view
plain
 copy

 

 print?

  1. public interface UserDAO {  
  2.      void save(User u);    
  3.      void delete();   
  4. }  

 

UserDAOImpl

 

[java] view
plain
 copy

 

 print?

  1. public class UserDAOImpl implements UserDAO {  
  2.      @Override    
  3.         public void save(User u) {    
  4.             System.out.println(“User:” + u.toString());    
  5.         }    
  6.         @Override    
  7.         public void delete() {    
  8.             System.out.println(“delete User”);    
  9.                 
  10.         }    
  11. }  

 

UserService

 

[java] view
plain
 copy

 

 print?

  1. public class UserService {  
  2.       
  3.    private UserDAO userDAO;    
  4.       
  5.    public void addUser(User u)    
  6.     {    
  7.         this.userDAO.save(u);    
  8.     }    
  9.     /**  
  10.      * @return the userDAO  
  11.      */    
  12.     public UserDAO getUserDAO()    
  13.     {    
  14.         return userDAO;    
  15.     }    
  16.     /**  
  17.      * @param userDAO  
  18.      *            the userDAO to set  
  19.      */    
  20.     public void setUserDAO(UserDAO userDAO)    
  21.     {    
  22.         this.userDAO = userDAO;    
  23.     }    
  24. }  

 

 

 

上面大家来归纳测试一下完成的效益:

 

Client

 

[java] view
plain
 copy

 

 print?

  1. public class client {  
  2.   
  3.     public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException, JDOMException, IOException {  
  4.     BeanFactory factory = new ClassPathXmlApplicationContext();   
  5.     //通过工厂直接拿走  
  6.         UserService userService = (UserService) factory.getBean(“userService”);   
  7.         //其实User也能够从工厂中获得  
  8.         User u=(User)factory.getBean(“user”);  
  9.         //User u = new User();    
  10.         u.setUserName(“yyb”);    
  11.         u.setPassword(“1234”);    
  12.         userService.addUser(u);//打印结果yyb1234  
  13.     }  
  14.   
  15. }  

 

 

 

理所当然以上我们是通过setter方法注入,还能使用构造器注入,也正是在确立指标的时候创建关系(即在UserService的构造函数中增多对userDAO的赋值操作)

 

总结:

 

以上通过IOC的八个简练完成实例,模拟了Spring中IOC的兑现,即使只是完结了Spring中凭借注入的一小部分做事,不过很好的显现了Java反射机制在Spring中的应用,能使大家能更好的从规律上精晓IOC的兑现,也能为大家贯彻团结的Spring框架提供了方案。

 

Spring
IOC达成原理demo:IOC

 

相关文章

Your Comments

近期评论

    功能


    网站地图xml地图