（从整合开始，使用回归使用eclipse）
一、三大框架版本：
struts2
hibernate5
spring4
二、SSH三大框架回顾：
Hibernate:
ORM思想
核心配置文件：
单独使用时名称和位置是固定，整合时不是固定的
会有一个HibernateTemplate的封装
Struts2:
核心组成：
action
处理提交表单数据，操作域对象
值栈
存取数据的方法
拦截器
AOP和责任链模式
Spring:
IoC和AOP是spring的灵魂
引入的是schema约束
三、SSH整合的思想
web：===struts2
service：===spring
dao:hibernaate
web调service,service调dao
整合思想就是两个两个整合：1.struts2和spring整合，2.spring和hibernate整合
1.把struts2里面的action对象的创建交给spring管理
需要记得配置除了 id 和 class ,还要有scope为prototype为多实例
2.把数据库配置信息交给spring
第一次访问时需要创建sessionFactory比较慢，把这个对象的创建交给spring管理
让对象在服务器在启动时创建
整合准备工作：
先列出所有jar图，后面导包不再单独贴图（从log4j处接上）
1.struts2和spring整合
新建项目：SSHDemo，整合目标是：使IOC容器来管理struts2的action
目录结构如下：
导入spring的14个jar包（day03里除去mysql驱动包）
再导入整合的jar包 ：struts-spring-plugin的jar包（如图所示，注意版本2.3.4）
再加整合web项目的jar包：spring-web.jar
接下来导入strus2的jar包（day03的jar加上jstl的两个包共15个包
建一个action:UserAction
package cn.action;
import com.opensymphony.xwork2.ActionSupport;
import cn.service.UserService;
public class UserAction extends ActionSupport {
//注入service
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
@Override
public String execute() throws Exception {
System.out.println("Hello SSH!");
userService.add();
return NONE;
}
}
（eclipse并没有自带jstl的包：jstl.jar standard.jar，找jstl在me里自带有））
配置struts.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="sshdemo1" extends="struts-default" namespace="/">
<!-- 没有返回值，不需要result -->
<action name="userAction" class="userAction"></action>
</package>
</struts>
不要忘了配置过滤器(在下面web.xml中一并列出)
创建spring的配置文件
把action由struts.xml交给spring管理（可以看struts-plugin.xml中可以看到相关的配置，将实例创建交给spring）
先从IOC容器获取，如果没有的话，就利用反射创建
<!-- 配置action对象，注意是多实例 -->
<bean id="userAction" class="cn.action.UserAction" scope="prototype">
<!-- 注入service -->
<property name="userService" ref="userService"></property>
</bean>
配置监听器：让服务器启动时加载一些需要的资源
配置context-param
（src下又叫类路径）
【更新】非web应用都是在main方法中直接创建得到IOC容器（applicationContext）
1.web应用我们希望在什么时候创建IOC容器呢，应该是在服务器启动时加载，当然这个时间我们是无法控制的，我们把这个任务交给监听器： ServletContextListener （由spring提供了一个监听器）
2.那么在web应用中如何访问IOC容器呢，我们把它(IOC容器)放在ServletContext(也是一个域对象中)
我们可以点开源码大致看一下，有类似的流程
- 在启动Web项目时，容器(比如Tomcat)会读web.xml配置文件中的两个节点<listener>和<contex-param>。
- 接着容器会创建一个ServletContext(上下文),应用范围内即整个WEB项目都能使用这个上下文。
- 接着容器会将读取到<context-param>转化为键值对,并交给ServletContext。
init-param类同
web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>SSHDemo</display-name>
<!-- 配置过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- spring的监听-->
<!-- 指定spring配置文件的位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:bean1.xml</param-value>
</context-param>
<!-- 配置监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
//context-param 和 listener 称为 spring的监听的配置
现在有两个配置文件都有配置action，会导致两边创建两次action
解决方案是stuts.xml中action的class不写全路径，写spring的id值（前提是要引入struts-spring-plugin的整合jar包）
<action name="userAction" class="userAction"></action>
2.spring和hibernate整合
搭建Hibernate环境，导入Hibernate的jar包
整合目标：使IOC容器去管理sessionFactory，并使hibernate程序用上声明式事务
导入整合orm框架的jar包：spring-orm——所有的持久层的东西都一定记得导入相关的驱动
核心就分三步：
配置数据源
导入资源文件（当然需要先创建）（加入<context>命名空间）
配置数据源信息
配置sessionFactory
由spring提供的LocalSessionFactoryBean实现（实例见下方）
配置声明式事务
注意事务管理器的名称变为 Hibernate的管理器（加入<tx><aop>）
三步的的细节（如需要注入的东西）见下文详细步骤
创建实体类：
User //必须有一个唯一属性值
package cn.entity;
public class User {
//实体类必须有一个唯一属性值
private String uid;
private String username;
private String password;
private String address;
public String getUid() {
return uid;
}
public void setUid(String uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User [uid=" + uid + ", username=" + username + ", password=" + password + ", address=" + address + "]";
}
}
创建映射文件User.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- 映射的类 name是类的全路径 table是表名 -->
<class name="cn.entity.User" table="t_ssh_user">
<id name="uid" column="uid">
<!-- 设置id增长策略 -->
<generator class="uuid"></generator>
</id>
<!-- 配置其它属性 -->
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<property name="address" column="address"></property>
</class>
</hibernate-mapping>
创建核心配置文件（引入工具类：创建的工具类不在同级目录下，按一下F5就好了...）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 一、配置数据库的信息，交给spring连接池替代 -->
<!-- <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property> -->
<!-- 二、配置hibernate信息 可选项 -->
<!-- 输出底层SQL语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 格式化SQL语句 -->
<property name="hibernate.format_sql">true</property>
<!-- 如果没有表，创建 已有表 更新 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置MySQL方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 三、引入映射文件 -->
<mapping resource="cn/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
配置后执行一下工具类，看配置是否正确
package cn.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
private static Configuration cfg = null;
private static SessionFactory sessionFactory = null;
//静态代码块实现
static {
cfg = new Configuration();
cfg.configure();
sessionFactory = cfg.buildSessionFactory();
}
//提供静态方法返回sessionFactory
public static SessionFactory getSessionFactory(){
return sessionFactory;
}
//返回本地线程绑定的session
public static Session getSessionObject(){
return sessionFactory.getCurrentSession();
}
public static void main(String[] args) {
}
}
把sessionFactory的创建交给spring管理：
LocalSessionFactoryBean是spring封装的类，帮我们加载配置文件，创建sessionFactory
也就是代替我们原来工具类的代码
<!-- 配置SessionFactory，交给spring管理 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 指定hibernate核心配置文件位置 -->
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
</bean>
dao使用HibernateTemplate:
先创建service和dao(Dao使用面向接口编程)
UserDao
package cn.dao;
public interface UserDao {
void add();
}
UserDaoImpl
package cn.dao;
import org.springframework.orm.hibernate5.HibernateTemplate;
import cn.entity.User;
public class UserDaoImpl implements UserDao {
//注意导的包是5的版本
private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
@Override
public void add() {
//使用配置文件实现
//创建模板，传入sessionFactory
/* HibernateTemplate hibernateTemplate =
new HibernateTemplate(sesseionFactory);*/
System.out.println("dao.add");
User user = new User();
user.setUsername("jack");
user.setPassword("123");
user.setAddress("北京");
hibernateTemplate.save(user);
}
}
UserService
package cn.service;
import javax.transaction.Transactional;
import cn.dao.UserDao;
@Transactional
public class UserService {
//注入dao,注意写接口(多态特性) UserDao dao = new UserDaoImpl()
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("service.add");
userDao.add();
}
}
完成注入关系：
action注入service service注入dao
在dao使用HibernateTemplate
在模板中注入sessionFactory
在dao中注入hibernateTemplate
配置事务管理器：
注入dataSource(day03)
现在建议注入sessionFactory (它包含dataSource)
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"></property
</bean>
<!-- 开启事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
在service类上加transactional注解(类的完整信息见上文)
@Transactional
public class UserService {
下面是 HibernateTemplate的常用方法。
delete(Object entity): 删除指定持久化实例。
deleteAll(Collection entities): 删除集合内全部持久化类实例。
find(String queryString): 根据 HQL 查询字符串来返回实例集合。
findByNamedQuery(String queryName): 根据命名查询返回实例集合。
get(Classentity Class,Serializable id): 根据主键加载特定持久化类的实例。
save(Object entity): 保存新的实例。
saveOrUpdate(Object entity): 根据实例状态，选择保存或者更新。
update(Object entity): 更新实例的状态，要求entity 是持久状态。
setMaxResults(intmax Results): 设置分页的大小。
这里只演示添加的save ，其它类同，对比Hibernate
find()方法可以查询所有记录，传入HQL，后面可以接可变参数
但是find()不能使用分页，需要使用离线的critria(待补充)
方法所在类为上文UserDaoImpl
@Override
public void add() {
//使用配置文件实现
//创建模板，传入sessionFactory
/*HibernateTemplate hibernateTemplate =
new HibernateTemplate(sesseionFactory);*/
System.out.println("dao.add");
User user = new User();
user.setUsername("jack");
user.setPassword("123");
user.setAddress("北京");
hibernateTemplate.save(user);
}
特别注意主键生成策略与主键的对应！uuid为对应String的id值！
DaImpl可以继承这个类HibernateDaoSupport，这个父类有模板属性和set()方法
并且里面有createHibernateTemplate，直接帮我们实现了注入。
直接注入sessionFactory即可，无需在配置文件中创建hibernateTemplate对象，也不用注入
在hibernate配置文件中配置了与本地线程绑定的session的配置
hibernateTemplate里面已经实现了，不需要在spring里再写了，那句配置可以去掉了<>thread</>
继承后得到HibernateTemplate:this.getHibernateTemplate()
package cn.dao;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
public class UserDaoImpl2 extends HibernateDaoSupport implements UserDao {
@Override
public void add() {
HibernateTemplate hibernateTemplate =
this.getHibernateTemplate();
}
}
大致过程小结：
框架整合大致过程：
导包：（如果公司，大多统一提供）
创建struts2环境
1)创建action,创建struts.xml,配置action
2)配置struts2过滤器
搭建hibernate环境
1）创建实体类
2）创建映射文件，建立表语实体类映射关系
3）创建核心配置文件，引入映射文件
搭建spring环境
1）创建spring核心配置文件
2）让spring在服务器启动时加载配置文件
配置监听器，指定spring配置文件路径
struts2和spring整合
1）action在spring配置（多实例）
在strutsxml的action的class写spring配置文件action的id值
spring和hibernate整合
1）把hibernate核心配置文件的数据库的配置在spring里配置（使用连接池）
2）把sessionFactory在spring配置（spring有一个封装的类）
记得对sessionFactory进行属性注入
完成action注入service;service注入dao;dao注入HibernateTemplate
dao里使用hibernate模板（先要创建模板对象才能注入）
配置事务
配置完成后需要加注解
完整的整合的三大配置文件信息如下：
bean1.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:aop="http://www.springframework.org/schema/aop"
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-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 进行属性注入 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/hibernate"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 配置SessionFactory，交给spring管理 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 指定hibernate核心配置文件位置 -->
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 开启事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!-- 配置action对象，注意是多实例 -->
<bean id="userAction" class="cn.action.UserAction" scope="prototype">
<!-- 注入service -->
<property name="userService" ref="userService"></property>
</bean>
<!-- 配置service对象 -->
<bean id="userService" class="cn.service.UserService">
<!-- 注入dao -->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<!-- 创建dao实现类对象 -->
<bean id="userDaoImpl" class="cn.dao.UserDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
<!-- 创建hibernateTemplate模板对象 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
<!-- 注入sessionFactory，上面已经创建，可以打开源码看属性 -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</beans>
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 一、配置数据库的信息，交给spring连接池替代 -->
<!-- <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property> -->
<!-- 二、配置hibernate信息 可选项 -->
<!-- 输出底层SQL语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 格式化SQL语句 -->
<property name="hibernate.format_sql">true</property>
<!-- 如果没有表，创建 已有表 更新 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置MySQL方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!-- 三、引入映射文件 -->
<mapping resource="cn/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
struts.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="sshdemo1" extends="struts-default" namespace="/">
<!-- 没有返回值，不需要result -->
<action name="userAction" class="userAction"></action>
</package>
</struts>
其它整合操作：（感觉第一种结构更简明）
1）整合hibernate框架的时候，把hibernate基本信息和引入映射都写入spring配置文件
这样，hibernate核心配置文件就可以去除了
打开类LocalSessionFactoryBean可以看到一些属性
先改配置文件 bean1.xml
配置hibernate基本信息
Properties hibernateProperties; 注入properties见前面属性注入
配置引入映射：
String[] mappingResources;注入集合的方式，可以注入多个
测试启动服务器多了一个表，即配置正常
<?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:aop="http://www.springframework.org/schema/aop"
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-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 进行属性注入 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/hibernate"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 配置SessionFactory，交给spring管理 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 指定hibernate核心配置文件位置 -->
<!-- <property name="configLocation" value="classpath:hibernate.cfg.xml"></property> -->
<!-- 配置hibernate基本信息 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
</props>
</property>
<!-- 配置映射文件引入 -->
<property name="mappingResources">
<list>
<value>cn/entity/User.hbm.xml</value>
</list>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 开启事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
<import resource="classpath:user.xml"/>
</beans>
spring分模块开发：
（之前的include引入可以解决，回顾struts2的分模块开发）
解决的是多人协作的维护问题
把核心配置文件的一部分：例如action部分拿出来
再用include单独引用
复制一份，删掉部分，进行引入（这里引入user.xml）
使用import
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:aop="http://www.springframework.org/schema/aop"
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-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 配置action对象，注意是多实例 -->
<bean id="userAction" class="cn.action.UserAction" scope="prototype">
<!-- 注入service -->
<property name="userService" ref="userService"></property>
</bean>
<!-- 配置service对象 -->
<bean id="userService" class="cn.service.UserService">
<!-- 注入dao -->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<!-- 创建dao实现类对象 -->
<bean id="userDaoImpl" class="cn.dao.UserDaoImpl">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
<!-- 创建hibernateTemplate模板对象 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
<!-- 注入sessionFactory，上面已经创建，可以打开源码看属性 -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</beans>
引入：(完整的bean1.xml见上文)
<import resource="classpath:user.xml"/>