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);
}
BeanFactory.java
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);
} }
ClassPathXmlApplicationContext.java
代码中的路径需要更改
介绍注入的两种方式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;
}
}
User.java
一个接口UserDAO
package com.ouc.wkp.dao; import com.ouc.wkp.model.User; public interface UserDAO {
public void save(User user);
}
UserDAO.java
接口实现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();
} }
UserDAOImpl.java
上面代码里面的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;
}
}
UserService.java
然后是两个配置文件,命名比较随意
<?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>
beans.xml
<?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>
beans1.xml
我们看一下配置文件
<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);
} }
UserServiceTest.java
运行结果如下
上面使用的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 } }
UserDAOImpl
在类的开头写上@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");
}
}
UserService.java
在类的开头写上@Component("userService")
在初始化方法前面写上@PostConstruct
在销毁方法前面写上@PreDestroy
在setUserDAO前面写上@Resource(name = "u")
注意这个name=“u” 和@Component("u")的对应关系
下一篇简单介绍aop和两种实现形式
spring IOC简单入门的更多相关文章
- 1.Spring IoC简单例子
Spring IoC简单例子 1.IHelloMessage.java package com.tony.spring.chapter01; public interface IHelloMessag ...
- spring security 简单入门
spring security 简单入门示例 一.概述 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架 . 其中最主要的安全操作有两 ...
- spring IOC简单分析
Spring IOC 体系结构 BeanFactory(BeanFactory 里只对 IOC 容器的基本行为作了定义,根本不关心你的 bean 是如何定义怎样加载的.正如我们只关心工厂里得到什么的产 ...
- Spring.Net 简单入门学习
Spring.NET IoC容器的用法. 通过简单的例子学习Spring.Net 1.先创建一个控制台程序项目. 2.添加IUserInfoDal 接口. namespace Spring.Net { ...
- spring AOP简单入门
AOP(aspect oriented programming)面向切面编程. 大致意思是在方法的执行过程中织入其他要执行的方法. 项目结构图 先介绍一下通过代理的方式实现aop,几个文件和上一篇一样 ...
- Spring AOP 简单入门笔记 (转)
分享一个自己写的最为简单的Spring AOP的应用,其实,本人也是学习Spring不久,只是把一些个人的理解分享下,供参考.可能很多人刚开始不太理解到底啥是AOP,其实它也是相对 OOP来说的,类似 ...
- Spring Cloud简单入门教程
原文地址:http://www.cnblogs.com/skyblog/p/5127690.html 按照官方的话说:Spring Cloud 为开发者提供了在分布式系统(如配置管理.服务发现.断路器 ...
- spring的简单入门
spring是一个轻量级的JavaEE解决方案,是众多优秀设计模式的整合.spring的核心是:(工厂)容器 1.设计模式:解决一些特定问题的经典代码.共有23中设计模式(工厂,单例,代理,适配,装饰 ...
- Spring Boot 简单入门
添加相关依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http ...
随机推荐
- padding-top、margin-top和top的区别
padding-top:10px;是指容器内的内容距离容器的顶部有10个像素,是包含在容器内的: margin-top:10px;是指容器本身的顶部距离其他容器有10个像素,不包含在容器内: top: ...
- Oracle Dataguard HA (主备,灾备)方案部署调试
包括: centos6.5 oracle11gR2 DataGuard安装 dataGuard 主备switchover角色切换 数据同步测试 <一,>DG数据库数据同步测试1,正常启动主 ...
- A Simple Problem with Integers(线段树,区间更新)
A Simple Problem with Integers Time Limit: 5000MS Memory Limit: 131072K Total Submissions: 83822 ...
- 从VS转MyEclipse的15天使用体验
脱离了VS强大的IDE功能之后,转向MyEclipse,发现很大差别,Java的IDE对比VS感觉弱很多,而且树形没有那么好用,Java里面是以包为主,区别与C#的最大就是,高亮提示关键字,这一点Ja ...
- iOS 证书那些事
关于开发证书配置(Certificates & Identifiers & Provisioning Profiles),相信做iOS开发的同学没少被折腾.对于一个iOS开发小白.半吊 ...
- errorPlacement的位置问题
做一个前端的验证,使用了JQUERY.Validate 在errorPlacement上纠结了半天: 百度大多数都是一个答案: errorPlacement: function(error, elem ...
- svn版本控制
svn自动生成X.java.mine,X.java.r2333,X.java.r2368文件 这是你和别人的操作形成了冲突: 你和别人都从2333这个版本对X.java进行了修改, 别人先修改之后,先 ...
- PHP系列笔记——Zend_Controller工作流程
Zend_Controller_Front接收请求,然后调用Zend_Controller_Router_Rewrite来决定哪个控制器被派遣.为了在请求中设置控制器和动作名称,Zend_Contro ...
- BZOJ 1415: [Noi2005]聪聪和可可( 最短路 + 期望dp )
用最短路暴力搞出s(i, j)表示聪聪在i, 可可在j处时聪聪会走的路线. 然后就可以dp了, dp(i, j) = [ dp(s(s(i,j), j), j) + Σdp(s(s(i,j), j), ...
- R与数据分析旧笔记(三)不知道取什么题目
连线图 > a=c(2,3,4,5,6) > b=c(4,7,8,9,12) > plot(a,b,type="l") 多条曲线效果 plot(rain$Toky ...