【框架】[Spring3]下载安装、开源框架与IoC控制反转详解

标签: springjavaxml开源框架框架
3326人阅读 评论(12) 收藏 举报
分类:

转载请注明出处: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

本文源自大学之旅_谙忆的博客

4
1

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1683652次
    • 积分:23383
    • 等级:
    • 排名:第286名
    • 原创:648篇
    • 转载:26篇
    • 译文:0篇
    • 评论:427条
    个人信息:


    我的邮箱:
    chxpostbox@outlook.com


    友情链接:
    博客专栏
    文章分类
    最新评论
    个人公众号
    扫一扫关注我的微信公众号
    不断为您推送精选博文、项目
    IT相关资讯、干货分享

    去右下角广告