码迷,mamicode.com
首页 > 编程语言 > 详细

spring框架总结(01)

时间:2017-10-07 14:53:24      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:zab   release   返回值   param   lob   oid   art   面向   org   

1、spring是什么?

   sprint其实就是一个开源框架,是于2003年兴起的一个轻量级的java开发框架,是有Road Johnson创建的,简单的来说spring是一个分层的JavaSE/EE(full-stack)也就是一站式轻量级的开源框架

  J2EE三层架构体系:

    表现层(页面数据显示,页面跳转调度)jsp/servlet

    业务层(业务处理和功能逻辑,事务控制) service

    持久层(数据存取和封装和数据库打交道)dao

 

spring框架主要有:Spring MVC  和JDBCTemplate模块 。

一般就是再使用的时候:在 表现层使用Struts2和Spring MVC        在业务层使用的是Spring    在持久层使用的是hibernate和JDBCTemplate

2、Spring的核心技术

IOC(表示的是反转控制)  也就是说将对象的创建权利交给Spring工场进行管理

AOP(表示的是面向切面编程) 原理是基于动态代理功能增强

3、学习Spring技术的好处

      (1)、方便解耦简化代码的开发-------Spring就是一个大工厂,可以将所有的对象的创建和关系的维护,交给Spring管理

      (2)、AOP编程的支持-------Spring提供了面向切面编程,可以方便的实现对程序进行权限拦截,运行监控和声明事务等功能

      (3)、声明事务的支持-------只需要进行配置就可以完成对事务的管理,而无需动手进行编程

      (4)、方便程序的测试--------Spring对Junit4支持,可以通过注解方便测试你Spring程序,方便继承各种优秀的框架

             总结:Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架的支持(如Struts、Hibernate、MyBatis、Quartz)

 

 

 

总结介绍使用:

IOC(Inverse of Control)  也就是控制反转就对象的创建权利交给Spring容器

解决问题:使用IOC可以解决程序耦合性过高的问题

 

IOC原理接受和准备工作

1、创建UserDao借口以及实现类UserDaoImpl

      

package cn.itcast.dao;

 

public interface UserDao {

 

   public void save();

  

}

实现类

package cn.itcast.dao.impl;

 

import cn.itcast.dao.UserDao;

 

public class UserDaoImpl implements UserDao {

 

   @Override

   public void save() {

      System.out.println("持久层:用户保存");

   }

 

}

 

2、创建UserService借口和实现类UserServiceImpl

    

package cn.itcast.service;

 

public interface UserService {

 

   public void save();

  

}

实现类

package cn.itcast.service.impl;

 

import cn.itcast.dao.UserDao;

import cn.itcast.dao.impl.UserDaoImpl;

import cn.itcast.service.UserService;

 

public class UserServiceImpl implements UserService {

  

   private UserDao userDao = new UserDaoImpl();

  

   @Override

   public void save() {

      System.out.println("业务层:用户保存");

      userDao.save();

   }

 

}

 

3、创建测试类测试

package cn.itcast.test;

 

import org.junit.Test;

 

import cn.itcast.service.UserService;

import cn.itcast.service.impl.UserServiceImpl;

 

public class Test1 {

 

   @Test

   public void test(){

      UserService userService = new UserServiceImpl();

      userService.save();

   }

}

 

4、创建另一个UserDao借口的实现类UserDaoImpl2

 

package cn.itcast.dao.impl;

 

import cn.itcast.dao.UserDao;

 

public class UserDaoImpl2 implements UserDao{

 

   @Override

   public void save() {

      System.out.println("持久层:用户保存2");

   }

 

}

 观察以上程序发现:UserService和UserDao耦合性过高,如果需要更换一个 UserDao的实现,则是需要修改源代码的

 

那么就是需要创建工厂类解决耦合性问题方法

工厂类的创建

package cn.itcast.utils;

 

import cn.itcast.dao.UserDao;

import cn.itcast.dao.impl.UserDaoImpl;

 

public class BeanFactory {

 

   public static UserDao getBean(){

      return new UserDaoImpl();

   }

}

 

创建工厂类的时候接下来就是要修改上述代码(修改UserServiceImpl实现类来获取UserDao的方式)

修改代码如下:

public class UserServiceImpl implements UserService {

  

// private UserDao userDao = new UserDaoImpl();

  

// 采用工厂类获取UserDao对象

   private UserDao userDao = BeanFactory.getBean();

  

   @Override

   public void save() {

      System.out.println("业务层:用户保存");

      userDao.save();

   }

 

}

总结发现:这个时候观察总结发现:当需要更换UserDao的实现的时候,不需要修改UserServiceImpl类,不过此时需要进行修改工厂类

 

最终终极解决方法:可以创建配置文件彻底解决耦合性的问题

1、在src下创建配置文件beans.xml

      

<?xml version="1.0" encoding="UTF-8"?>

<bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl2"></bean>

2、同时修改工厂类从配置文件中读取对象

     代码如下:

public class BeanFactory {

  

   //存放所有的对象

   private static final Map<String,Object> map = new HashMap<String,Object>();

  

   static{

      SAXReader sax = new SAXReader();

      try {

         Document document = sax.read(BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"));

         Element root = document.getRootElement();

         //获取id属性的值

         String id = root.attributeValue("id");

         //获取class属性的值

         String value = root.attributeValue("class");

         //根据class属性的值实例化对象

         Object obj = Class.forName(value).newInstance();

         //把对象存放到Map中

         map.put(id, obj);

      } catch (Exception e) {

         e.printStackTrace();

      }

   }

  

   /**

    * 根据id获取对象

    * @param id

    * @return

    */

   public static Object getBean(String id){

      return map.get(id);

   }

}

 

3、修改UserServiceImpl类

public class UserServiceImpl implements UserService {

  

// private UserDao userDao = new UserDaoImpl();

  

// 采用工厂类获取UserDao对象

// private UserDao userDao = BeanFactory.getBean();

  

// 从配置文件中读取需要的对象

   private UserDao userDao = (UserDao) BeanFactory.getBean("userDao");

 

   @Override

   public void save() {

      System.out.println("业务层:用户保存");

      userDao.save();

   }

 

}

这个时候总结发现:当需要更改UserDao的时候,只需要修改配置文件就可以实现,不用更改源代码了,这个时候程序也就是会彻底解决耦合性过高的问题

 

3、Spring开发包的下载:

 1.)官网地址https://spring.io/

 2)下载 地址:http://repo.spring.io/libs-release-local/org/springframework/spring/    建议下载4.2.4这个版本

介绍一个开发包的目录结构:

docs    表示的是开发文档

libs      表示开发时候所需要的jar包

schema:表示开发的时候所需要的约束文件

其他 的暂时不用考虑

注意:开发过程中还需要其他开源技术框架依赖Jar包集(dependencies,作用是方便依赖的其他技术的jar的导入)

 

Spring核心容器中是需要四个jar包的:分别是beans 、context、Core、SpEl核心jar包

同时还需要加入和日志相关的两个jar包,从spring-framework-3.0.2.RELEASE-dependencies中寻找

 

 

 

5、介绍Spring中的工厂

5.1、 ApplicationContext接口

   

 使用ApplicationContext工厂的接口,使用该接口可以获取到具体的Bean对象

 该接口下有两个具体的实现类

 

 ClassPathXmlApplicationContext            -- 加载类路径下的Spring配置文件

 FileSystemXmlApplicationContext            -- 加载本地磁盘下的Spring配置文件

相关代码实现:

public class Test1 {

 

   @Test

   public void test1(){

      ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

      UserDao userDao = (UserDao) applicationContext.getBean("userDao");

      userDao.save();

   }

  

   @Test

   public void test2(){

      ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:/spring/applicationContext.xml");

      UserDao userDao = (UserDao) applicationContext.getBean("userDao");

      userDao.save();

   }

  

}

 

1.1. BeanFactory工厂

早期版本的工厂介绍:

BeanFactory是Spring框架早期的创建Bean对象的工厂接口

 

  

/**

    * 早期版本的spring工厂:BeanFactory

    */

   @Test

   public void test3(){

      BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

      System.out.println("工厂对象创建出来了");

      UserDao userDao = (UserDao) factory.getBean("userDao");

      userDao.save();

   }

 

 BeanFactory和ApplicationContext的区别
            * BeanFactory   (表示的是早期的ioc工厂) -- BeanFactory采取延迟加载,第一次getBean时才会初始化Bean
            * ApplicationContext        -- 在加载applicationContext.xml时候就会创建具体的Bean对象的实例,还提供了一些其他的功能:
                 * 事件传递
                 * Bean自动装配
                 * 各种不同应用层的Context实现

 

6、Spring配置文件的介绍

 6.1  id属性:id属性是bean的唯一标识

 6.2 class属性:表示的是bean的全路径名称  <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"/>

6.3 Scope属性:scope属性代表Bean的作用范围

                          

                           singleton:单例(默认值)

                          prototype:多例,在Spring框架整合Struts2框架的时候,Action类也需要交给Spring做管理,配置把Action类配置成多例!!

                          request:应用在web应用中,将创建的对象存入到request域中。

                          session:应用在web应用中,将创建的对象存入到session域中

                          globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

实例:

singleton:单例(默认值)

prototype:多例,在Spring框架整合Struts2框架的时候,Action类也需要交给Spring做管理,配置把Action类配置成多例!!

request:应用在web应用中,将创建的对象存入到request域中。

session:应用在web应用中,将创建的对象存入到session域中

globalsession:应用在porlet环境下使用。将创建的对象存入到全局的session中。

                                           <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" scope="prototype"/>

 

 

两者直接的区分:

修改测试类:    ClassPathXMLApplication表示的你是直接从类路径下面进行加载,表示类只要一创建就立刻加载出来了。

@Test

public void test1(){

      ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

      System.out.println("工厂对象创建出来了");

      UserDao userDao = (UserDao) applicationContext.getBean("userDao");

      UserDao userDao1 = (UserDao) applicationContext.getBean("userDao");

      userDao.save();

}

测试发现:当scope为prototype时,每次获取bean,都会重新实例化

 

 

6.4、init-method属性

当bean被载入到容器的时候调用init-method属性指定的方法

public class UserDaoImpl implements UserDao {

  

   public UserDaoImpl() {

      System.out.println("调用了UserDaoImpl的构造方法");

   }

  

   public void init(){

      System.out.println("调用了init方法...");

   }

 

   @Override

   public void save() {

      System.out.println("用户保存...");

   }

 

}

实例:

<bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init"/>

 

6.5、 destory-method属性

当bean从容器中删除的时候调用destroy-method属性指定的方法

想查看destroy-method的效果,有如下条件:

           scope= singleton有效

           web容器中会自动调用,但是main函数或测试用例需要手动调用(需要使用ClassPathXmlApplicationContext的close()方法)

@Test

public void test1(){

      ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

      System.out.println("工厂对象创建出来了");

      UserDao userDao = (UserDao) applicationContext.getBean("userDao");

      userDao.save();

      //要看到destroy方法执行,需要调用ClassPathXmlApplicationContext.close方法

      ((ClassPathXmlApplicationContext)applicationContext).close();

}

 

总结:就是Spring框架的5中属性,分别是id属性,class属性,scope属性,init-method属性,destory-method属性

 

 

7、Spring生成bean的三种方式

    7.1  表示无参构造方法--------------默认调用无参构造方法实例化bean

    7.2  静态工厂实例化方式----------通过调用工厂类的静态方法实例化生成bean

     

n  编写DepartmentDao接口

package cn.itcast.dao;

 

public interface DepartmentDao {

 

   public void save();

}

n  编写DepartmentDaoImpl实现类

package cn.itcast.dao.impl;

 

import cn.itcast.dao.DepartmentDao;

 

public class DepartmentDaoImpl implements DepartmentDao{

 

   @Override

   public void save() {

      System.out.println("部门保存...");

   }

 

}

n  编写工厂类

package cn.itcast.dao.impl;

 

import cn.itcast.dao.DepartmentDao;

 

public class DepartmentDaoFactory {

 

   /**

    * 静态工厂方法获取对象

    * @return

    */

   public static DepartmentDao create(){

      return new DepartmentDaoImpl();

   }

}

n  编写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"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>

        <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean>

</beans>

 

7.3  实例工厂方式

      

n  实例工厂代码:

package cn.itcast.dao.impl;

 

import cn.itcast.dao.DepartmentDao;

 

public class DepartmentDaoFactory {

 

   /**

    * 静态工厂方法获取对象

    * @return

    */

   public static DepartmentDao create(){

      return new DepartmentDaoImpl();

   }

  

   /**

    * 实例工厂方法获取对象

    * @return

    */

   public DepartmentDao create1(){

      return new DepartmentDaoImpl();

   }

}

n  编写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"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>

       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->

        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>

        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>

</beans>

 

总结:Spring生成bean的三种方式 :无参构造方法,静态工厂实例化方式,实力工厂方式

 

8、依赖注入(重点学习使用)(其中有八种方法可以实现依赖注入实现)

 

依赖注入的介绍:

IOC和DI的概念:
        * IOC        -- Inverse of Control,控制反转,将对象的创建权反转给Spring!!
        * DI        -- Dependency Injection,依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件中!!

如果UserServiceImpl的实现类中有一个属性,那么使用Spring框架的IOC功能时,可以通过依赖注入把该属性的值传入进来!!

 

总共有八种:

1、构造方法注入

package cn.itcast.domain;

 

public class Car implements Serializable{

private static final long serialVersionUID = 1L;

   private String name;

   private Double price;

  

   public Car(String name, Double price) {

      this.name = name;

      this.price = price;

   }

 

   public String getName() {

      return name;

   }

 

   public void setName(String name) {

      this.name = name;

   }

 

   public Double getPrice() {

      return price;

   }

 

   public void setPrice(Double price) {

      this.price = price;

   }

 

   @Override

   public String toString() {

      return "Car [name=" + name + ", price=" + price + "]";

   }

  

}

n  配置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"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>

       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->

        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>

        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>

        <!-- 构造方法注入 -->

        <bean id="car" class="cn.itcast.domain.Car">

          <constructor-arg name="name" value="奥迪A6"></constructor-arg>

          <constructor-arg name="price" value="57.3"></constructor-arg>

        </bean>

</beans>

2、set方法注入

 

public class Student implements Serializable {

 

   private static final long serialVersionUID = 1L;

  

   private Long id;

   private String name;

  

   public Long getId() {

      return id;

   }

   public void setId(Long id) {

      this.id = id;

   }

   public String getName() {

      return name;

   }

   public void setName(String name) {

      this.name = name;

   }

   @Override

   public String toString() {

      return "Student [id=" + id + ", name=" + name + "]";

   }

}

n  配置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"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>

       <!--  <bean id="departmentDao" class="cn.itcast.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->

        <bean id="departmentDaoFactory" class="cn.itcast.dao.impl.DepartmentDaoFactory" ></bean>

        <bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>

        <!-- 构造方法注入 -->

        <bean id="car" class="cn.itcast.domain.Car">

          <constructor-arg name="name" value="奥迪A6"></constructor-arg>

          <constructor-arg name="price" value="57.3"></constructor-arg>

        </bean>

        <!-- set方法注入 -->

        <bean id="student" class="cn.itcast.domain.Student">

          <property name="id" value="11"></property>

          <property name="name" value="张三"></property>

        </bean>

</beans>

 

3、set方法注入的其他写法(不常用)

3.1  p命名空间的写法

新建car1类

package cn.itcast.domain;

 

public class Car1 {

 

   private String name;

   private double price;

  

   public void setName(String name) {

      this.name = name;

   }

在applicationContext.xml中引入p命名空间

 

 

   public void setPrice(double price) {

      this.price = price;

   }

   @Override

   public String toString() {

      return "Car1 [name=" + name + ", price=" + price + "]";

   }

  

}

 技术分享

 

n  采用p:属性名的形式注入值(spring2.5提供的)

 <!-- p命名空间注入 -->

 <bean id="car1" class="cn.itcast.domain.Car1" p:name="奔驰" p:price="100.2">

 </bean>

SpEL的写法(spring3.0提供)

 <!-- SpEL注入 -->

 <bean id="car1" class="cn.itcast.domain.Car1">

       <property name="name" value="#{‘哈弗H5‘}"></property>

        <property name="price" value="#{10}"></property>

 </bean>

注入字符串:#{‘字符串’}

注入数字:#{数字}

注入其它对象:#{对象id}

 <bean id="people" class="cn.itcast.domain.People">

          <property name="name" value="#{‘小明‘}"></property>

          <property name="car" value="#{car}"></property>

 </bean>

n  还可以注入其它对象的属性或方法的返回值

public class CarInfo {

 

   public String getCarName(){

      return "宝骏560";

   }

  

   public double calculatePrice(){

      return Math.random() * 10000;

   }

}

 

 <bean id="carInfo" class="cn.itcast.domain.CarInfo"></bean>

 <!-- SpEL注入 -->

<bean id="car1" class="cn.itcast.domain.Car1">

       <!-- <property name="name" value="#{‘哈弗H5‘}"></property>

       <property name="price" value="#{10}"></property> -->

       <property name="name" value="#{carInfo.carName}"></property>

       <property name="price" value="#{carInfo.calculatePrice()}"></property>

 </bean>

注意:#{carInfo.carName}会调用getCarName方法获取汽车的名称;而#{carInfo.calculatePrice()}会直接调用calculatePrice方法获取汽车价格。

 

5、数组或者是list注入

数组和list注入的写法是一样的

n  新建bean类

public class CollectionBean {

 

   private String[] array;

 

   public void setArray(String[] array) {

      this.array = array;

   }

 

   @Override

   public String toString() {

      return "CollectionBean [array=" + Arrays.toString(array) + "]";

   }

  

}

n  在applicationContext.xml中配置

<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">

          <property name="array">

             <list>

                <value>威少</value>

                <value>哈登</value>

                <value>莱昂纳德</value>

             </list>

          </property>

</bean>

 

6.Set集合注入

public class CollectionBean {

 

   private String[] array;

   private Set<String> set;

 

   public void setArray(String[] array) {

      this.array = array;

   }

 

   public void setSet(Set<String> set) {

      this.set = set;

   }

 

   @Override

   public String toString() {

      System.out.println(set.getClass());

      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + "]";

   }

 

}

 

<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">

          <property name="array">

             <list>

                <value>威少</value>

                <value>哈登</value>

                <value>莱昂纳德</value>

             </list>

          </property>

          <property name="set">

             <set>

                <value>苹果</value>

                <value>梨子</value>

                <value>香蕉</value>

             </set>

          </property>

</bean>

提示:spring在注入set的时,给我们注入的是一个LinkedHashSet,所以在输入set集合中的元素时,是按照我们注入的顺序来的,并不是无序的。

 

 

7Map集合的注入

public class CollectionBean {

 

   private String[] array;

   private Set<String> set;

   private Map<String,String> map;

 

   public void setArray(String[] array) {

      this.array = array;

   }

 

   public void setSet(Set<String> set) {

      this.set = set;

   }

  

   public void setMap(Map<String, String> map) {

      this.map = map;

   }

 

   @Override

   public String toString() {

      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + "]";

   }

 

}

 

<bean id="collectionBean" class="cn.itcast.domain.CollectionBean">

          <property name="array">

             <list>

                <value>威少</value>

                <value>哈登</value>

                <value>莱昂纳德</value>

             </list>

          </property>

          <property name="set">

             <set>

                <value>苹果</value>

                <value>梨子</value>

                <value>香蕉</value>

             </set>

          </property>

          <property name="map">

             <map>

                <entry key="id" value="11"></entry>

                <entry key="name" value="张三"></entry>

                <entry key="age" value="20"></entry>

             </map>

          </property>

</bean>

 

8、properties集合的注入

public class CollectionBean {

 

   private String[] array;

   private Set<String> set;

   private Map<String,String> map;

   private Properties props;

 

   public void setArray(String[] array) {

      this.array = array;

   }

 

   public void setSet(Set<String> set) {

      this.set = set;

   }

  

   public void setMap(Map<String, String> map) {

      this.map = map;

   }

 

   public void setProps(Properties props) {

      this.props = props;

   }

 

   @Override

   public String toString() {

      return "CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + ", props=" + props

            + "]";

   }

 

}

 

 <bean id="collectionBean" class="cn.itcast.domain.CollectionBean">

          <property name="array">

             <list>

                <value>威少</value>

                <value>哈登</value>

                <value>莱昂纳德</value>

             </list>

          </property>

          <property name="set">

             <set>

                <value>苹果</value>

                <value>梨子</value>

                <value>香蕉</value>

             </set>

          </property>

          <property name="map">

             <map>

                <entry key="id" value="11"></entry>

                <entry key="name" value="张三"></entry>

                <entry key="age" value="20"></entry>

             </map>

          </property>

          <property name="props">

             <props>

                <prop key="username">李四</prop>

                <prop key="password">123</prop>

             </props>

          </property>

 </bean>

 

1.1. 配置文件的分离

Spring配置文件的分离有两种方式:

(1)采用import标签导入另一个配置文件

Bean1类

 

public class Bean1 {

   private String xxx;

   public String getXxx() {

      return xxx;

   }

   public void setXxx(String xxx) {

      this.xxx = xxx;

   }

   @Override

   public String toString() {

      return "Bean1 [xxx=" + xxx + "]";

   }

}

 

applicationContext2.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

   xmlns:p="http://www.springframework.org/schema/p"

    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.xsd">

    <bean id="bean1" class="cn.itcast.demo.Bean1">

      <property name="xxx" value="hello"></property>

    </bean>

</beans>

 

在applicationContext.xml中引入applicationContext2.xml文件

<import resource="applicationContext2.xml"/>

 

(2)在实例化ApplicationContext的时候,指定多个配置文件

@Test

   public void test9(){

      ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

      Bean1 bean1 = (Bean1) ac.getBean("bean1");

      System.out.println(bean1);

   }

spring框架总结(01)

标签:zab   release   返回值   param   lob   oid   art   面向   org   

原文地址:http://www.cnblogs.com/lilong329329/p/7634146.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!