spring IOC简单入门
spring的核心是ioc和aop
先介绍一下IOC（inverse of control控制反转）又叫DI（Dependency injection依赖注入）
个人理解为把对象的控制权由类转移到配置文件中 把类所需要的对象通过配置文件注入到类中 可以表述不太准确
我们可以模拟spring 的BeanFactory和ClassPathXmlApplicationContext 但是这不重要
package com.ouc.wkp.spring; public interface BeanFactory { public Object getBean(String id); }
package com.ouc.wkp.spring; import java.lang.reflect.Method; import java.util.HashMap; import java.util.List; import java.util.Map; import org.jdom2.Document; import org.jdom2.Element; import org.jdom2.input.SAXBuilder; public class ClassPathXmlApplicationContext implements BeanFactory{ private Map<String, Object> beans=new HashMap<String,Object>(); public ClassPathXmlApplicationContext() throws Exception{ SAXBuilder sb = new SAXBuilder(); Document doc = sb.build("src\\com\\ouc\\wkp\\test\\beans.xml"); // 构造文件对象 Element root = doc.getRootElement(); // 获取根元素HD List<?> list = root.getChildren("bean");// 取名字为bean的所有元素 for (int i = 0; i < list.size(); i++) { Element element = (Element) list.get(i); String id = element.getAttributeValue("id"); String clazz = element.getAttributeValue("class"); Object o=Class.forName(clazz).newInstance(); System.out.println(id); System.out.println(clazz); beans.put(id,o); for(Element propertyElement:(List<Element>)element.getChildren("property")){ String name=propertyElement.getAttributeValue("name"); String bean=propertyElement.getAttributeValue("bean"); //u Object beanObject=beans.get(bean); //UserDAOImpl instance String methodName="set" +name.substring(0,1).toUpperCase()+name.substring(1); System.out.println("method name="+methodName); Method m=o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);//setUserDAO(UserDAO) m.invoke(o, beanObject); } } } @Override public Object getBean(String id) { return beans.get(id); } }
代码中的路径需要更改
介绍注入的两种方式xml和annotation，先介绍xml方式
项目结构图 下面是注入的实例 先一个User实体类
package com.ouc.wkp.model; public class User { private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }
一个接口UserDAO
package com.ouc.wkp.dao; import com.ouc.wkp.model.User; public interface UserDAO { public void save(User user); }
接口实现UserDAOImpl
package com.ouc.wkp.dao.impl; import java.util.List; import java.util.Map; import java.util.Set; import com.ouc.wkp.dao.UserDAO; import com.ouc.wkp.model.User; public class UserDAOImpl implements UserDAO { public void save(User user) { // Hibernate // JDBC // XML // NetWork System.out.println("user saved!"); } private Set<String> sets; private List<String> lists; private Map<String, String> maps; public Set<String> getSets() { return sets; } public void setSets(Set<String> sets) { this.sets = sets; } public List<String> getLists() { return lists; } public void setLists(List<String> lists) { this.lists = lists; } public Map<String, String> getMaps() { return maps; } public void setMaps(Map<String, String> maps) { this.maps = maps; } public UserDAOImpl() { } @Override public String toString() { return "sets size:" + sets.size() + "| lists size:" + lists.size() + "| maps size:" + maps.size(); } }
上面代码里面的list set map 和 toString方法是测试通过配置文件给对象里面的属性赋值
然后是UserService
package com.ouc.wkp.service; import com.ouc.wkp.dao.UserDAO; import com.ouc.wkp.model.User; public class UserService { private UserDAO userDAO; private UserService(UserDAO userDAO) { this.userDAO = userDAO; } public void init(){ System.out.println("init"); } public void destroy(){ System.out.println("destroy"); } public void add(User user) { userDAO.save(user); } public UserDAO getUserDAO() { return userDAO; } public void setUserDAO(UserDAO userDAO) { this.userDAO = userDAO; } }
然后是两个配置文件，命名比较随意
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <!-- default-autowire= --> <!-- 在spring中，singleton属性默认是true，只有设定为false，则每次指定别名取得的Bean时都会产生一个新的实例 --> <bean id="u" class="com.ouc.wkp.dao.impl.UserDAOImpl" /> <!-- 自动装配 autowire --> <!-- scope 生命范围 singleton单例 prototype每次创建新的对象 --> <!-- init-method="" destory-method=""--> <bean id="userservice" class="com.ouc.wkp.service.UserService" scope="prototype" init-method="init" destroy-method="destroy"> <!-- 指set方法 注入 --> <!-- <property name="userDAO" ref="u" /> --> <constructor-arg> <ref bean="u" /> </constructor-arg> </bean> </beans>
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id="userDAO" class="com.ouc.wkp.dao.impl.UserDAOImpl"> <property name="sets"> <set> <value>1</value> <value>2</value> </set> </property> <property name="lists"> <list> <value>1</value> <value>2</value> <value>3</value> </list> </property> <property name="maps"> <map> <entry key="1" value="1"></entry> <entry key="2" value="2"></entry> <entry key="3" value="3"></entry> <entry key="4" value="4"></entry> </map> </property> </bean> <bean id="userService" class="com.ouc.wkp.service.UserService"> <!-- <property name="userDAO"> <ref bean="userDAO"/> </property> --> <constructor-arg> <ref bean="userDAO"/> </constructor-arg> </bean> </beans>
我们看一下配置文件
<beans></beans>是最外层标签
第一层子元素是<bean></bean>标签 代表一个类实例化时的对象
属性id用于唯一标识这个对象。
class用于指定这个类文件的位置，输入完毕后按ctrl，如果生成可以跳转的链接说明输入正确。
scope代表生命范围，默认是singleton即单例模式，如果设置为prototype则每次实例化都生成一个新的对象。
init-method="init" destroy-method="destroy"标识对象初始化和销毁时分别调用init() 和destroy()方法。
可以设置autowire来进行自动装配，但是有时容易产生混乱，也可以在<beans>标签里面加上default-autowire。
然后是重点
<bean id="userservice" class="com.ouc.wkp.service.UserService" scope="prototype" init-method="init" destroy-method="destroy">
<!-- 指set方法 注入 -->
<!-- <property name="userDAO" ref="u" /> -->
<constructor-arg>
<ref bean="u" />
</constructor-arg>
</bean>
看UserService.java这个类里面有个
private UserDAO userDAO;
然后我们为他写上get set方法。这样就可以通过配置文件注入这个对象。
我们注意到注入的bean ref=“u” 这个u和和上面声明的userDAO的id相同。
注入有3种方法 第一种是上面注释的set方法注入 第二种是上面的构造方法注入
因为我们在UserService里面有构造方法
private UserService(UserDAO userDAO) {
this.userDAO = userDAO;
}
所以我们必须要采用构造方法注入，如何注释掉构造方法就可以采用第一种。
第三种接口注入，没有去了解。
最后是一个junit测试类
package com.ouc.wkp.test; import static org.junit.Assert.*; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.ouc.wkp.dao.UserDAO; import com.ouc.wkp.model.User; import com.ouc.wkp.service.UserService; //import com.ouc.wkp.spring.BeanFactory; //import com.ouc.wkp.spring.ClassPathXmlApplicationContext; public class UserServiceTest { @Test public void testAdd() throws Exception{ ClassPathXmlApplicationContext ctx1=new ClassPathXmlApplicationContext("beans.xml"); UserService service=(UserService)ctx1.getBean("userservice"); UserService service2=(UserService)ctx1.getBean("userservice"); System.out.println(service==service2); User user=new User(); user.setUsername("heihei"); user.setPassword("1234"); service.add(user); ApplicationContext ctx2=new ClassPathXmlApplicationContext("beans1.xml"); UserDAO userDAO=(UserDAO)ctx2.getBean("userDAO"); System.out.println(userDAO); } }
运行结果如下
上面使用的xml方式，下面介绍annotation方式，方便了很多。
首先需要在配置文件里面加上这些
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<context:annotation-config />
使用这种方式，我们就不需要在xml中声明bean。上面xml中的两个bean标签可以删去。
两个类作了修改
package com.ouc.wkp.dao.impl; import org.springframework.stereotype.Component; import com.ouc.wkp.dao.UserDAO; import com.ouc.wkp.model.User; @Component("u") public class UserDAOImpl implements UserDAO { @Override public void save(User user) { // Hibernate // JDBC // XML // NetWork System.out.println("user saved!"); // throw new RuntimeException(); } @Override public void delete() { // TODO Auto-generated method stub } }
在类的开头写上@Component("u")
package com.ouc.wkp.service; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import javax.annotation.Resource; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Component; import com.ouc.wkp.dao.UserDAO; import com.ouc.wkp.model.User; @Component("userService") public class UserService { private UserDAO userDAO; @PostConstruct public void init() { System.out.println("init"); } public void add(User user) { userDAO.save(user); } public UserDAO getUserDAO() { return userDAO; } // @Autowired @Qualifier("u") @Resource(name = "u") public void setUserDAO(UserDAO userDAO) { this.userDAO = userDAO; } @PreDestroy public void destroy() { System.out.println("destroy"); } }
在类的开头写上@Component("userService")
在初始化方法前面写上@PostConstruct
在销毁方法前面写上@PreDestroy
在setUserDAO前面写上@Resource(name = "u")
注意这个name=“u” 和@Component("u")的对应关系
下一篇简单介绍aop和两种实现形式
