【框架】[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

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

时间： 2024-12-23 05:17:46

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

Spring IoC[控制反转]

近段时间正在学习spring.对于spring IOC发表一下自己的见解 1 spring IoC 1.1 什么是IoC 控制反转(Inversion of Control,英文缩写为IoC).主要是用来降低程序之间耦合度的一种方式. 1.2 IoC主要形式 ◇依赖查找:容器提供回调接口和上下文条件给组件.组件就必须使用容器提供的API来查找资源和协作对象,容器将调用这些回调方法,从而让应用代码获得相关资源. ◇依赖注入:组件不做定位查询,只提供普通的Java方法让容器去决定依赖关系.容器全权负

CentOS下安装MySQL5.6.10和安全配置教程详解_Mysql

注:以下所有操作都在CentOS 6.5 x86_64位系统下完成. #准备工作# 在安装MySQL之前,请确保已经使用yum安装了以下各类基础组件(如果系统已自带,还可以考虑yum update下基础组件): gcc cmake openssl+openssl-devel pcre+pcre-devel bzip2+bzip2-devel libcurl+curl+curl-devel libjpeg+libjpeg-devel libpng+libpng-devel freetype+fre

Android异步下载图片并且缓存图片到本地DEMO详解

在Android开发中我们经常有这样的需求,从服务器上下载xml或者JSON类型的数据,其中包括一些图片资源,本demo模拟了这个需求,从网络上加载XML资源,其中包括图片,我们要做的解析XML里面的数据,并且把图片缓存到本地一个cache目录里面,并且用一个自定义的Adapter去填充到LIstView,demo运行效果见下图: 通过这个demo,要学会有一下几点 1.怎么解析一个XML 2.demo中用到的缓存图片到本地一个临时目录的思想是怎样的? 3.AsyncTask类的使用,因为要去异

Centos 安装ImageMagick 与 imagick for php步骤详解

关于什么是ImageMagick ImageMagick是一套软件系列,主要用于图片的创建.编辑以及转换等 Centos 安装ImageMagick 1. 依次运行以下命令  代码如下 复制代码 yum install ImageMagick yum install ImageMagick-devel yum install php-pear [for PECL] 安装php-pear是为了使用pecl 中的 phpize , ?]的???霈F ERROR: `phpize' failed  

Android 开源项目侧边栏菜单(SlidingMenu)使用详解_Android

项目下载地址:https://github.com/jfeinstein10/SlidingMenu 注意: SlidingMenu依赖于另一个开源项目ActionBarSherlock,所以需要将ActionBarSherlock添加作为SlidingMenu的库工程,否则会报资源找不到错误. 然后再将SlidingMenu添加到自己的工程中去. SlidingMenu集成常见错误: Jar mismatch! Fix your dependencies :引用的工程和自身工程以来的jar包版

IoC 控制反转

控制反转一般分为两种类型,依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup).依赖注入应用比较广泛. 控制反转(IOC)模式(又称DI:Dependency Injection)就是Inversion of Control,控制反转.在Java开发中,IoC意 味着将你设计好的类交给系统(一般是容器)去控制,而不是在你的类内部控制.这称为控制反转. IoC可以认为是一种全新的设计模式,但是理论和时间成熟相对较晚,并没有包含在GoF中.

Linux下安装jdk报Permission denied以及chmod详解

一.发现问题 在Linux中安装jdk.bin的时候发现问题,报错./config.sh: line 103: /home/jdk.bin : Permission denied 修改权限:chmod 775 /home/jdk.bin 二.chmod命令详解 文件/目录权限设置命令:chmod 用于改变文件或目录的访问权限 用法1:其语法格式为:chmod [who] [opt] [mode] 文件/目录名         其中who表示对象,是以下字母中的一个或组合: u:表示文件所有者 g

【微框架】Maven +SpringBoot 集成 阿里大鱼 短信接口详解与Demo

Maven+springboot+阿里大于短信验证服务 纠结点:Maven库没有sdk,需要解决 Maven打包找不到相关类,需要解决 一.本文简介 在工作当中的项目中,我遇到过这种情况,公司架构选型SpringBoot ,这是个基于Maven构建的项目, 需要集成阿里大鱼短信系统,然后暴露REST风格的API接口出去.本文重点讲解. 二.开发准备 阿里大于,是阿里的通讯产品之一,提供短信验证码服务. 1.需要注册阿里大鱼账户.充值.设置,这一块不多讲,官网有文档. (https://www.a

Java的MyBatis框架中关键的XML字段映射的配置参数详解_java

properties这些是外部化的,可替代的属性,这些属性也可以配置在典型的Java属性配置文件中,或者通过properties元素的子元素来传递.例如: <properties resource="org/mybatis/example/config.properties"> <property name="username" value="dev_user"/> <property name="pass