框架[Spring3]下载安装开源框架与IoC控制反转详解
Posted 谙忆
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了框架[Spring3]下载安装开源框架与IoC控制反转详解相关的知识，希望对你有一定的参考价值。
转载请注明出处：http://blog.csdn.net/qq_26525215
本文源自【大学之旅_谙忆的博客】
昨天刚刚初学Spring3,也许Spring3有点老了哈，不过还是先把3学了再去学习4吧，首先先介绍一下如何去下载Spring的必须包吧。
(本篇博客适用于初学Spring的朋友)
java spring4现在不推荐使用xml配置文件…
当然啦，这些知识点在Spring4还是可以用的。
不过我在这里详解的还是Spring3哈，见谅~
下载SpringJAR包/文档:
Spring官网:http://spring.io/
Spring3.2版本以后(JAR/文档)的下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring/
（如果无法访问，请准备梯子）
选择一个需要下载的版本进去:
我选择的是最新的4.3.2版本.
spring-framework-*(版本号).RELEASE-dist.zip 包含了Spring必须的JAR包、DOC文档以及源代码等。
下载完之后解压我们就可以在spring-framework-4.3.2.RELEASE\\libs找到需要包和DOC文档以及源代码了。
由于最新版本的已经提倡基于Java Config和注解的配置，不采用xml配置了，所以，我在这里准备的是Spring3.1.1版本的:
下载链接:
https://github.com/chenhaoxiang/Java/blob/master/Spring/spring-framework-3.1.1.RELEASE.zip
Spring开源框架
Spring框架的起始:
Spring在英语中含义就是”春天”.
对于Java EE开发者来说，Spring框架出现确实带来了一股全新的春天的气息。
早在2002年，Rod Johson在其编著的《Expert one to one J2EE design and development》书中，对Java EE框架臃肿、低效、脱离现实的种种现状提出了很多质疑，并积极寻求探索革新之道。
由他主导编写了interface21框架，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。以interface21框架为基础，并集成了其它许多开源成果，于2004年3月24日，发布了1.0正式版取名为Spring。
Spring框架模块：
Spring的核心是个轻量级容器，实现了IoC（控制翻转）模式的容器，基于此核心容器所建立的应用程序，可以达到程序组件的松散耦合。这些特性都使得整个应用程序维护简化。 Spring框架核心由下图所示的七个模块组成。
现在来分别介绍一下这七个模块:
1、核心容器(Core)
这是Spring框架最基础的部分，它提供了依赖注入（Dependency Injection）特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory，它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。
2、AOP模块
AOP即面向切面编程技术，Spring在它的AOP模块中提供了对面向切面编程的丰富支持。AOP允许通过分离应用的业务逻辑与系统级服务（例如安全和事务管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。
3、对象/关系映射集成模块ORM
Hibernate是成熟的ORM产品，Spring并没有自己实现ORM框架而是集成了几个流行的ORM产品如Hibernate、JDO和iBATIS等。可以利用Spring对这些模块提供事务支持等。
4、JDBC抽象和DAO模块
Spring虽然集成了几个ORM产品，但也可以不选择这几款产品，因为Spring提供了JDBC和DAO模块。该模块对现有的JDBC技术进行了优化。你可以保持你的数据库访问代码干净简洁，并且可以防止因关闭数据库资源失败而引起的问题。
[JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构管管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。SpringDAO的面向JDBC的异常遵从从通用的DAO异常层次结构]
5、Spring的Web模块
Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。另外，这个模块还提供了一些面向服务支持。例如：实现文件上传的multipart请求，它也提供了Spring和其它Web框架的集成，比如Struts、WebWork。
6、应用上下文（Context）模块
核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。该模块还提供了一些面向服务支持这个模块扩展了BeanFactory的概念，增加了对国际化（I18N）消息、事件传播以及验证的支持。
另外，这个模块还提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括对模版框架例如Velocity和FreeMarker集成的支持。
7、Spring的MVC框架
Spring为构建Web应用提供了一个功能全面的MVC框架。虽然Spring可以很容易地与其它MVC框架集成，例如Struts2，但Spring的MVC框架使用IoC对控制逻辑和业务对象提供了完全的分离。
Spring入门示例
将需要的Jar包导入项目、
再准备一个xml配置文件:
applicationContext.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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
</beans>
将Spring的压缩包解压后：你可以在spring-framework-3.1.1.RELEASE\\projects\\org.springframework.web.portlet\\src\\test\\java\\org\\springframework\\web\\portlet\\context\\WEB-INF目录下找到applicationContext.xml。我们只需要这个部分就可以了。
将文件建立在src目录下(建在另外的路径也可以)。
导入必须的包，和建好applicationContext.xml文件。
1、编写一个普通的Java类（JavaBean）
package cn.hncu.demo1.domain;
public class Person {
private String name;
private int age;
public Person() {
System.out.println("执行Person的构造方法....");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
2、在Spring配置文件applicationContext.xml。将JavaBean由Spring容器来管理。
<beans ...>
<!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
<bean id="p" class="cn.hncu.demo1.domain.Person" scope="prototype">
</bean>
</beans>测试方法:
@Test
public void demo1(){
//此方法已在3.0版本中过时，不建议使用
//BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
//Spring3.0建议采用下面这种方式使用容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person p = (Person) ctx.getBean("p");//通过配置的id获得，需要强转
System.out.println(p);
Person p2 = ctx.getBean(Person.class);//通过Person的Class对象去获得，不需要强转
System.out.println(p2);
}输出结果:
显然，Person只构造了一次。
由于我们没给初值，所以name是null，age因为是int型，所以是0.
现在我们在applicationContext.xml中来给它配置好初值，然后看:
<!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
<bean id="p" class="cn.hncu.demo1.domain.Person">
<!-- 配置好初始值 -->
<property name="name" value="张三"></property>
<property name="age" value="23"></property>
</bean>再一次的运行结果:
演示依赖(XML)注入
在servlet注入servicce，Person，
在servicce注入dao，
LoginDAO
package cn.hncu.demo1.login.dao;
import cn.hncu.demo1.domain.Person;
public interface LoginDAO {
public void login(Person p);
}
LoginDaoJdbc
package cn.hncu.demo1.login.dao;
import cn.hncu.demo1.domain.Person;
public class LoginDaoJdbc implements LoginDAO{
@Override
public void login(Person p) {
System.out.println("dao,到数据库中读取用户信息以进行登录....");
System.out.println("dao中获取的用户输入信息:"+p);
}
}
ILoginService
package cn.hncu.demo1.login.service;
import cn.hncu.demo1.domain.Person;
public interface ILoginService {
public void login(Person p);
}
LoginServiceImpl
package cn.hncu.demo1.login.service;
import cn.hncu.demo1.domain.Person;
import cn.hncu.demo1.login.dao.LoginDAO;
public class LoginServiceImpl implements ILoginService{
private LoginDAO dao = null;
//如果要注入，需要注入的成员变量，必须写好set-get方法！
public LoginDAO getDao() {
return dao;
}
public void setDao(LoginDAO dao) {
this.dao = dao;
}
@Override
public void login(Person p) {
dao.login(p);
}
}
LoginAction
package cn.hncu.demo1.login;
import cn.hncu.demo1.domain.Person;
import cn.hncu.demo1.login.service.ILoginService;
public class LoginAction {
private ILoginService service = null;
private Person p = null;
//如果要注入，需要注入的成员变量，必须写好set-get方法！
public ILoginService getService() {
return service;
}
public void setService(ILoginService service) {
this.service = service;
}
public Person getP() {
return p;
}
public void setP(Person p) {
this.p = p;
}
public void execute(){
service.login(p);
}
}
需要依赖注入的变量一定要写好setter-getter 方法哦！！！
测试方法:
@Test//演示依赖(XML)注入
public void demo2(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
LoginAction action = ctx.getBean(LoginAction.class);
//LoginAction action = ctx.getBean("login",LoginAction.class);
action.execute();
}
配置文件:
<beans ...>
<!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
<bean id="p" class="cn.hncu.demo1.domain.Person">
<!-- 配置好初始值 -->
<property name="name" value="张三"></property>
<property name="age" value="23"></property>
</bean>
<!-- 注意这里的class是实现类，而不是接口哦 -->
<bean id="dao" class="cn.hncu.demo1.login.dao.LoginDaoJdbc">
</bean>
<!-- 注意这里的class也是实现类，而不是接口哦 -->
<!-- 如果换实现类了，只需把这里的class变了就可以了 -->
<bean id="s" class="cn.hncu.demo1.login.service.LoginServiceImpl">
<!-- 实现类中还有变量，ref是另外的bean的id-引用 -->
<property name="dao" ref="dao"></property>
</bean>
<bean id="login" class="cn.hncu.demo1.login.LoginAction">
<property name="service" ref="s"></property>
<property name="person" ref="p"></property>
</bean>
</beans>结构图：
运行测试方法后的输出结果:
现在增加一个DAO的实现类，可以在程序中无需代码改变，就可以注入不同实例.
我们只需要改applicationContext.xml：
<!-- 注意这里的class是实现类，而不是接口哦 -->
<!-- 如果换实现类了，只需把这里的class变了就可以了,或者不动这里，增加一个bean -->
<bean id="dao" class="cn.hncu.demo1.login.dao.LoginDaoJdbc2">
</bean>增加的DAO实现类：
package cn.hncu.demo1.login.dao;
import cn.hncu.demo1.domain.Person;
public class LoginDaoJdbc2 implements LoginDAO{
@Override
public void login(Person p) {
System.out.println("dao2,到数据库中读取用户信息以进行登录....");
System.out.println("dao2中获取的用户输入信息:"+p);
}
}
改动后的演示结果:
Spring IOC 控制反转
IoC(Inversion of Control)中文译为控制反转也可以叫做DI（Dependency Injection，依赖注入）。
控制反转模式的基本概念是：不直接创建对象，但是在xml配置文件中描述创建它们的方式。
在工程中使用该Bean时由Spring容器创建Bean的实例。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。
1、Spring注入(又称依赖注入DI):
其目的是为其中bean的属性赋值
通过Setter方法。（一般属性赋值即基本类型赋值示例）
第1步：编写JavaBean-必须写set方法
package cn.hncu.demo2.domain;
public class Cat {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Cat [name=" + name + "]";
}
}
第2步: 在配置文件中注入属性的初始值
<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<bean id="cat" class="cn.hncu.demo2.domain.Cat">
<!-- 初始化name -->
<property name="name" value="黑猫"></property>
</bean>
</beans>
这样拿到的Cat对象就有初始值了，name的初始值为”黑猫”。
复杂数据类型的初始化：
例如，含有List，Map，Set，或者其他对象的数据，这样的bean对象如何初始化值呢。
结构如下:
Cat类就是前面那个。
User
package cn.hncu.demo2.domain;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class User {
private String name;
private Integer age;
private List<Object> pets;
private Map<String, Object> map;
private Set<Object> set;
private Object objs[];
private Cat cat;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public List<Object> getPets() {
return pets;
}
public void setPets(List<Object> pets) {
this.pets = pets;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
public Set<Object> getSet() {
return set;
}
public void setSet(Set<Object> set) {
this.set = set;
}
public Object[] getObjs() {
return objs;
}
public void setObjs(Object[] objs) {
this.objs = objs;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", pets=" + pets
+ "\\r\\n map=" + map + "\\r\\n set=" + set + "\\r\\n objs="
+ Arrays.toString(objs) + ", cat=" + cat + "]";
}
}
配置文件
在这里我取名为：applicationContext2.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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<bean id="cat" class="cn.hncu.demo2.domain.Cat">
<!-- 初始化name -->
<property name="name" value="黑猫"></property>
</bean>
<bean id="user" class="cn.hncu.demo2.domain.User">
<property name="name" value="Jack"></property>
<property name="age" value="25"></property>
<property name="pets">
<list>
<value>cat</value>
<value>dog</value>
<value>tiger</value>
</list>
</property>
<property name="map">
<map>
<entry key="name" value="中国"></entry>
<entry key="age" value="67"></entry>
<!-- ref是引用 -->
<entry key="cat" value-ref="cat"></entry>
</map>
</property>
<property name="set">
<set>
<!-- 引用 -->
<ref bean="cat"/>
<value>aaa</value>
<value>bbb</value>
</set>
</property>
<property name="objs">
<!-- 数组 -->
<array>
<value>hrllo</value>
<ref bean="cat"/>
<list>
<value>obj1</value>
<value>obj2</value>
</list>
<bean class="cn.hncu.demo2.domain.Cat">
<property name="name" value="白猫"></property>
</bean>
</array>
</property>
</bean>
</beans>
测试类:
package cn.hncu.demo2;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.hncu.demo2.domain.User;
public class Demo2 {
//演示spring中<bean>属性注入的一些细节
@Test
public void demo(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext2.xml");
User user = ctx.getBean("user",User.class);
System.out.println(user);
}
}
测试结果:
如果对于这个User的类的赋值搞懂了，我想应该在这块就会很熟练了。
完整的项目源码:
https://github.com/chenhaoxiang/Java/blob/master/Spring/mySpring3Demo/mySpring3Demo.zip
本文章由[谙忆]编写， 所有权利保留。
转载请注明出处：http://blog.csdn.net/qq_26525215
本文源自【大学之旅_谙忆的博客】
以上是关于框架[Spring3]下载安装开源框架与IoC控制反转详解的主要内容，如果未能解决你的问题，请参考以下文章
框架 day36 Spring3 入门,DI依赖注入,装配bean基于xml/注解, 整合Junit4,配置约束自动提示