关闭

Spring框架1-容器功能

标签: spring框架
1082人阅读 评论(0) 收藏 举报
分类:

核心容器(Core)

这是Spring框架最基础的部分,它提供了依赖注入(Dependency Injection)特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory,它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现,它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。
spring的容器中注入各个实例,使得他们在同一个空间,方便。而且是通过xml配置文件new出来的 不依赖类,解耦。
<bean>中给一个scope属性可以控制spring的作用域:

1、singleton单实例

当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。换言之,当把一个bean定义设置为singleton作用域时,Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存(singleton cache)中,并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例。

2、prototype多实例

每个Spring容器中,一个bean对应多个实例. prototype作用域部署的bean,每一次请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)都会产生一个新的bean实例,相当一个new的操作。

3、request

request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效.

简单使用Spring框架

1、编写一个普通的Java类(JavaBean)

注意的是:这个类中要用的属性我们都要写好setter-getter函数,这样spring才能封装

package cn.hncu.login;

public class Person {
    private String name;
    private Integer age;

    public Person() {
        System.out.println("执行Person的构造方法...");
    }
    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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

2、在Spring配置文件applicationContext.xml。将JavaBean由Spring容器来管理。

<?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-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <bean id="p" class="cn.hncu.login.Person">
        <property name="name" value="Alice"></property>
        <property name="age" value="25"></property>
    </bean>

</beans>

3、使用Spring容器配置的Bean

注意,在spring2.5版本中是通过XmlBeanFactory来拿beanfactory的。在3.x版本中是通过另一个类:ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");来拿benafactory的,另外2.5版本是不带泛型的,而3.x版本可以带泛型,当然3.x版本也能用2.5版本的方式拿。

package cn.hncu.login;

import org.junit.Test;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Demo {
    @Test
    public void demo1(){
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        Person p = (Person) factory.getBean("p");
        System.out.println(p);
        Person p2 = (Person) factory.getBean("p");
        System.out.println(p2);
    }
}

至此,一个简单的spring就是这样的了。

使用面向接口编程技术使用spring–3.x版本

1、 Person类 –javabean

package cn.hncu.spring3x.domain;

public class Person {
    private String name;
    private Integer age;

    public Person() {
        System.out.println("执行Person的构造方法...");
    }
    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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

2、ILoginDAO–dao接口

package cn.hncu.spring3x.login.dao;

import cn.hncu.spring3x.domain.Person;

public interface ILoginDAO {
    public void login(Person p);
}

3、LoginDAOImpl–dao实现类

package cn.hncu.spring3x.login.dao;

import cn.hncu.spring3x.domain.Person;

public class LoginDAOImpl implements ILoginDAO {

    @Override
    public void login(Person p) {
        System.out.println("dao,到数据库中读取用户信息以进行登录....");     
        System.out.println("dao中获取的用户输入信息:"+p);
    }

}

4、ILoginService –service接口

package cn.hncu.spring3x.login.service;

import cn.hncu.spring3x.domain.Person;

public interface ILoginService {
    public void login(Person p);
}

5、LoginServiceImpl–service实现类

package cn.hncu.spring3x.login.service;

import cn.hncu.spring3x.domain.Person;
import cn.hncu.spring3x.login.dao.ILoginDAO;

public class LoginServiceImpl implements ILoginService{
    private ILoginDAO dao = null;
    public ILoginDAO getDao() {
        return dao;
    }
    public void setDao(ILoginDAO dao) {
        this.dao = dao;
    }

    @Override
    public void login(Person p) {
        dao.login(p);
    }

}

6、LoginAction–Action 相当于servlet

package cn.hncu.spring3x.login;

import cn.hncu.spring3x.domain.Person;
import cn.hncu.spring3x.login.service.ILoginService;

public class LoginAction{
    private ILoginService service = null;
    private Person p = null;
    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);
    }
}

7、TestDemo–测试类

package cn.hncu.spring3x;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

import cn.hncu.spring3x.domain.Person;
import cn.hncu.spring3x.login.LoginAction;

public class TestDemo {
    @Test
    public void demo1(){
        //用spring3.x版本
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = ctx.getBean(Person.class);
        System.out.println(p);
    }
    @Test
    public void demo2(){
        //用spring3.x版本
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        LoginAction action = ctx.getBean(LoginAction.class);
        action.execute();
    }


}

8、applicationContest.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="p" class="cn.hncu.spring3x.domain.Person">
        <property name="name" value="WYJ"></property>
        <property name="age" value="22"></property>
    </bean>
    <bean id="dao" class="cn.hncu.spring3x.login.dao.LoginDAOImpl"></bean>
    <bean id="dao2" class="cn.hncu.spring3x.login.dao.LoginDAOImpl2"></bean>
    <bean id="service" class="cn.hncu.spring3x.login.service.LoginServiceImpl">
        <property name="dao" ref="dao2"></property>
    </bean>
    <bean id="login" class="cn.hncu.spring3x.login.LoginAction">
        <property name="service" ref="service"></property>
        <property name="p" ref="p"></property>
    </bean>
</beans>

细节:

我们一定要注意的是,我们要用的类的相关属性一定要写setter-getter函数,然后在xml中配置<property>

Spring IOC 控制反转

IoC(Inversion of Control)中文译为控制反转也可以叫做DI(Dependency Injection,依赖注入)。
控制反转模式的基本概念是:不直接创建对象,但是在xml配置文件中描述创建它们的方式。在工程中使用该Bean时由Spring容器创建Bean的实例。在代码中不直接与对象和服务连接,但在配置文件中描述哪一个组件需要哪一项服务。
下面我给一个比较复杂的注入来理解IOC

User类

package cn.hncu.spring3x.demo2;

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<String> pets;//list集合
    private Map<String, Object> map;//map集合
    private Set<String> set;
    private Object[] objs;

    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<String> getPets() {
        return pets;
    }
    public void setPets(List<String> pets) {
        this.pets = pets;
    }


    public Map<String, Object> getMap() {
        return map;
    }
    public void setMap(Map<String, Object> map) {
        this.map = map;
    }


    public Set<String> getSet() {
        return set;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }


    public Object[] getObjs() {
        return objs;
    }
    public void setObjs(Object[] objs) {
        this.objs = objs;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", pets=" + pets
                + ", map=" + map + ", set=" + set + ", objs="
                + Arrays.toString(objs) + "]";
    }


}

Cat类

package cn.hncu.spring3x.demo2;

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 + "]";
    }

}

测试类

package cn.hncu.spring3x.demo2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo2 {
    /*
     * 演示spring注入的一些细节
     */
    @Test
    public void test(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("app2.xml");
        User user = ctx.getBean(User.class);
        System.out.println(user);
    }
}

这里我们要提的就是这个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="tom" class="cn.hncu.spring3x.demo2.Cat">
        <property name="name" value="Tom猫"></property>
    </bean>
    <bean id="user" class="cn.hncu.spring3x.demo2.User">
        <property name="name" value="凡杰"></property>
        <property name="age" value="23"></property>
        <property name="pets">
            <list>
                <value>cat</value>
                <value>dog</value>
                <value>tiger</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="city" value="湖南"></entry>
                <entry key="school" value="湖南城市学院"></entry>
                <entry key="freind" value="小威"></entry>
            </map>
        </property>
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>
        <property name="objs">
            <array>
                <value>城院教学楼</value>
                <ref bean="tom"/>
                <list>
                    <value>信息院</value>
                    <value>城管院</value>
                </list>
                <bean id="jack" class="cn.hncu.spring3x.demo2.Cat">
                    <property name="name" value="天才宠物猫"></property>
                </bean>

            </array>
        </property>
    </bean>
</beans>

从这个xml中我们可以明显看到如果是复杂类型的数据并且不是类对象的时候我们是打开<property></property>通过在它里面给相关的配置来做到的。

1
0
查看评论

Spring框架参考文档-目录

Spring框架的一,概述 1。入门春天2。介绍了Spring框架 2.1。依赖注入和控制反转2.2。模块 2.2.1。核心容器2.2.2。数据访问/集成2.2.3。卷筒纸2.2.4。AOP和仪表2.2.5。测试 2.3。使用场景 2.3.1。依赖关系管理及命名惯例 Spring的依赖和取...
  • idofzhan
  • idofzhan
  • 2014-02-10 19:30
  • 1155

SSH答疑解惑系列(一)——spring容器是如何启动的

在实现Struts的小demo的时候,我们在地址栏输入http://localhost:8080/OA/userSave.action 后,就可以跳转到Action包中的UserAction中,那么这是如何实现的呢? 在项目的web.xml中,整合spring的配置。 整合spring——监听器...
  • u010066934
  • u010066934
  • 2016-01-02 17:21
  • 1300

Spring之旅--简述Spring框架及各项功能

老习惯,在学习一种技术之前,我们要明白一个问题,那就是即将要学习的技术到底是什么,能够解决什么问题?
  • qq_24976967
  • qq_24976967
  • 2017-01-20 17:19
  • 170

Spring框架基础知识

1.Spring框架的由来与发展: (1).Spring是Java Web三大经典框架(Struts、Spring、Hibernate ,SSH)中主要用于降低模块之间耦合度的框架,实际上Spring除了能够通过IoC降低模块之间的耦合度外,还提供了其它功能。 (2).2002年,Rod Johns...
  • u012561176
  • u012561176
  • 2015-05-25 19:36
  • 2303

Spring 框架的7个模块的简介

Spring 框架是一个分层架构,由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式。如图: 组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。 ...
  • u013385368
  • u013385368
  • 2014-11-21 17:16
  • 488

springMVC中spring容器启动流程

springMVC中spring容器启动过程,从web.xml配置文件开始分析。 org.springframework.web.context.ContextLoaderListener ContextLoaderListener监听ServletContex的初始化,Servlet...
  • a1240302901
  • a1240302901
  • 2015-03-13 11:05
  • 999

Spring框架:Spring容器详解

Spring容器 Spring容器可以帮助你管理所有的Bean对象,专业术语称之为IoC控制反转。在传统的程序中,对象的生成都是由开发者完成的。而在控制反转中,对象的生成全部都交给框架完成。这样的好处就是减少了程序的依赖性。 Bean在Spring中的生命周期如下: 实例化。Spr...
  • caipeichao2
  • caipeichao2
  • 2014-09-18 21:40
  • 4602

Spring框架介绍和IoC容器中Bean配置(Spring框架)

Spring框架知识点整理 Spring概述      ①Spring为简化企业级开发而生,使用Spring,JavaBean就可以实现很多以前要靠EJB才能实现的功能。同样的功能,在EJB中要通过繁琐的配置和复杂的代码才能够实现,而在Spring中却非常的优雅和简...
  • wangligong
  • wangligong
  • 2016-11-10 23:01
  • 2229

Spring框架:核心容器总结

最近想要深入了解一下spring,所以今天先对spring框架做一个宏观的总结。 Spring框架: 首先我们看到Spring框架被分成7部分:Core Container(核心容器),Data Access/Integration、WEB、AOP、Instrumentation、Messagin...
  • cd18333612683
  • cd18333612683
  • 2017-10-22 19:14
  • 379

Spring框架之容器(applicationContex.xml)

发现贴PPT的内容很麻烦,这里就不贴了,就贴一些课堂笔记和代码吧。O(∩_∩)O~~ 简单介绍 Spring有两项技术:容器和AOPSpring现在已经从2.5到3.0,现在已经到了4.0版本,但是最好还是从2.5开始学起。在Spring配置文件applicationContext.xml(...
  • zuosixiaonengshou
  • zuosixiaonengshou
  • 2017-01-02 15:38
  • 485
    个人资料
    • 访问:66223次
    • 积分:1651
    • 等级:
    • 排名:千里之外
    • 原创:103篇
    • 转载:1篇
    • 译文:0篇
    • 评论:6条
    最新评论