一
整合铺垫
WEB项目下怎么运行Spring（之前都是写在java项目下，在main方法中运行的），及整合时IOC容器放在了哪个共同区域供其它框架使用？（放在了application作用域）
*和其它框架整合是以spring为桥梁，[ 使用spring IOC容器来管理，其它框架的重要对象 ]，以Spring IOC、AOP为基础，对其它框架进行增强 和 控制 。
既然管理的是其它框架的重要对象，那么其它框架有什么重要对象呢？
1.struts2的重要对象就这两个：action 和 interceptor ，ognl只算做表达式语言
2.hibernate的重要对象：SessionFactory(一个数据库的内存镜像)、session
问题1****************Spring怎么用？就是建立一个IOC容器，从里面new对象，再从里面拿对象！！！！！！****************************
代码，当然要配合xml使用(xml见前面的文章)
public static void main(String[ ] arg){
ApplicationContext ac = new ClassPathXmlApplicationContext(
new String[ ] {"applicationContext.xml"}
);
MyClassDao myClassDao = (MyClassDao)ac.getBean("myClassDao");
System.out.println(myClassDao.getClass.getName());
myClassDao.add();
myClassDao.del();
//用IOC容器new出对象后该怎么用还怎么用，调用方法啥的。。
}
问题2************在web项目下怎么运行Spring?之前的实例都是写在main方法中，是java项目，web项目没有main方法，是基于事件，通过容器启动的，要怎么运行?********
在web项目下，一段java代码的执行，一般基于特定事件，如下三种情形
（web项目下，java代码的触发条件）
1.web项目下基于http，请求——响应模型：一个请求过来，会有一个servlet或是filter来执行这段代码
2.服务器启动init、服务器关闭destroy，对应着项目的加载和项目的销毁
3.Listener 监听器，就是在web环境下，专门为了响应一些事件。监听器有很多种，其中有一种就是为了监听服务器的启动。其它的还有Session Listener、Request Listener、 Application Listener、也有为整个项目服务的Listener，有二、三十种，它是基于某个特定的事件的。
Spring在web项目下运行，解决方案
1.在项目启动时，创建IOC容器，选用这种方法启动会很慢，一般会加个Lazy，让IOC容器中的类在用时再创建
示例
1），建立一个web项目，建立一个包com.test.init包，在包下创建一个servlet，名叫InitServlet
public class InitServlet extends HttpServlet {
public void init() throws ServletException{
System.out.println("Spring IOC初始化！！！");
}
}
2），在web.xml中配置servlet
<servlet>
<servlet-name>initServlet</servlet-name>
<servlet-class>com.bjsxt.init.InitServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
mapping就不用配置了，因为这次测试不需要让人访问，只是测试IOC容器创建，这是通过初始化tomcat时启动运行IOC容器
3），启动项目，就会通过初始化项目执行创建IOC容器了，这里只是用一句打印模拟了IOC容器的创建，需要换成真正的代码。
2.使用监听器启动IOC容器
1），建立包com.test.listener，里面有一个类ContextLoadListener.java
public class ContextLoadListener implements ServletContextListener { //servlet上下文监听
public void contextDestroyed(ServletContextEvent arg0){
}
public void contextInitialized(ServletContextEvent arg0){
System.out.println("Spring IOC初始化！！");
}
}
2），web.xml中的配置
<listener>
<listener-class>com.test.listener.ContextLoadListener</listener-class>
</listener>
3），启动项目，就会通过Listener执行创建IOC容器了，这里只是用一句打印模拟了IOC容器的创建，需要换成真正的代码
以上是两种怎样在web项目中创建IOC容器的方法（不是通过运行main方法），创建好IOC容器后，spring会在容器中创建其它框架的重要对象，怎么去拿这些对象来用呢？
问题3*************Spring的IOC容器存放到什么地方，方便其它框架从中获取相应bean？？
（ IOC容器放到什么地方大家才都能知道呢？web环境下能存储信息的，有什么地方？四个作用域！而application是共同都能访问到的*********************）
在web环境下，把IOC放到application中，来供别的框架获取
示例代码
1），建立一个web项目，把jar包拷入项目
aspectjrt.jar
aspectjveaver.jar
cglib-nodep-2.1_3.jar
commons-logging.jar
spring-sources.jar
spring.jar
2），把配置文件拷贝过来，放到WEBB-INF下的lib下面！！ApplicationContext.xml，作测试用，只配置简单的UserDao
<bean id="userDao" class="com.bjsxt.dao.UserDao"></bean>
3），建立一个包com.test.dao，里面建立一个UserDao.java
public class UserDao{
public UserDao(){
System.out.println("init......");
}
public void add(){
System.out.println("add......");
}
}
4），在web.xml中配置
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
5），现在启动web项目，IOC容器已经能创建了，是通过web.xml配置文件创建的。
6），在index.jsp中添加如下代码
<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1" %> //要导入util包
<body>
<%
//先打印application中有哪些值，从而看看里面有没有IOC容器
Enumeration enm = (Enumeration) application.getAttributeNames();
while(enm.hasMoreElements()){
String str=(String)enm.nextElement();
out.println(str+"<br/>");
}
//通过ac容器获得bean的另一种方法
ApplicationContext ac = (ApplicationContext) application.getAttribute("org.springframework.web.context.WebApplicationContext.ROOT");
UserDao userDao = (UserDao) ac.getBean("userDao");
userDao.add();
%>
</body>
7），运行项目，访问http://localhost:8080/项目名/index.jsp，看打印出来有没有IOC容器
8），现在的运行结果是index.jsp页面上打印出application作用域里的所有值，控制台打印执行add方法的结果。这样的结果表明spring成功将IOC容器放到了application作用域中，供其它框架来获取。
二
Spring中整合struts2
问题，如果applciationContext.xml非想要放到src下（默认应该放在WEB-INF下），怎么办？
答：1.在web.xml当中添加如下
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
2.这样就可以把applicationContext.xml放在src下面了。运行项目试试吧
整合开始*******************************************
前提是Spring环境已经搭建好（jar包，applicationContext.xml已经拷贝到项目中）
1.建立一个包com.test.action，里面建类UserAction.java
public class UserAction{
private UserDao userDao;
public UserDao getUserDao(){
return userDao;
}
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
public String add(){
return null;
}
}
2.在applicationContext.xml中配置如下
<bean id="userAction" class="com.bjsxt.action.UserAction" scope="prototype" > //这句的意思是这个action是多例的，这里一定要加scope="prototype"，因为struts2是多例的，不然会报错
<property name="UserDao" ref="userDao"></property>
</bean>
3.把struts2的1ar包拷贝到项目中
（框架版本不一样，jar包内容会有些不同，2.3版本struts有asm包<asm包操作字节码的>，2.2没有，意味着2.1版本2.2版本没有动态代理，2.3版本加入了动态代理的支持）
a) apps\struts2-blank\WEB-INF\lib下的所有jar包都拷入
b) 把web.xml中的filter拷贝到自己项目
c) struts.xml拷到src下
4.在struts.xml中添加如下配置
<struts>
<constant name="struts.objectFactory" value="spring" ></constant> <!--这是个全局配置，有了这个配置，struts2就不会自己创建对象了-->
<package name="default" namespace="/" extends="struts-default"> //原本的struts2 action是这样写，class里是包名<action name="" class="com.bjsxt.action.UserAction"></action>
<action name="userAction" class="userAction" ></action> //有了IOC容器后不用写包名了，因为class里写的是IOC容器中action的ID，通过这个action的ID，去容器中去拿出来一个bean，当成action来使用。而且每次拿出的对象都是新的对象。这个class要和applicationContext.xml中的<bean id="">的id一样！！！
</package>
</struts>
5.有专门的jar包负责spring和struts2的连接，这个jar包是必导入的
在struts-2.2.1\lib\struts2-spring-plugin-2.2.1.1.jar，把它拷贝到项目下
6.测试
在上面的UserAction.java类中做如下改动
public String add(){
userDao.add();
return null;
}
7.还没有创建UserDao方法，如下
public class UserDao{
public UserDao(){
System.out.println("init......");
}
public void add(){
System.out.println("add......");
}
}
8.重启项目，访问http://localhost:8080/项目名/userAction!add
控制台能打印说明，整合是成功的，请求从filter到IOC到action到dao。
每刷新访问一次就多打印一个add，说明action是多例的，整合中确保struts2是多例的非常重要。
总结Struts2和spring整合必须的三步****************************
1.Struts2知道SpringIOC容器的存在<constant name="struts.objectFactory" value="spring"></constant>
2.actioni的class设置为applicationContext.xml中对应bean的id
<package name="default" namespace="/" extends="struts-default">
<action name="userAction" class="userAction"></action>
</package>
3.需要增加一个jar来处理struts2和spring之间的联系 struts-2.2.1\lib\struts2-spring-plugin-2.2.1.1.jar
——————Spring 和 Struts2 整合 end——————————————
Spring和hibernate整合
Spring来管理SessionFactory和Session
回顾SessionFactory的三类配置信息：
1.数据库连接信息（driver驱动 用户名 密码）
2.hibernate全局参数
3.mapping映射文件信息
*想由spring来管理SessionFactory，必须由Spring来配置这三类信息才可以
spring提供了hibernate的辅助工具类（提供了一个类），来帮我们管理SessionFactory的创建
这个类是放在Spring-framework-2.5.6\src\org\springframework\orm\hibernate3下的LocalSessionFactoryBean.java，这个类是spring管理sessionFactory创建的一个最重要的类。还有一个子类也起相同作用：AnnotationSessionFactoryBean
LocalSessionFactoryBean配置过程中比较重要的属性（可以通过反编译工具看这个类的源码得知）
1.String[ ] mappingResources这个属性管理的是hibernate中mapping的映射文件信息
2.properties hibernateProperties管理的是hibernate中的全局参数，也可以包含数据库连接信息
3.dataSource Pool通过数据库连接池管理连接，也可以直接创建连接
现在是直接创建连接的示例————————————————
示例代码
1.applicationContext.xml
<bean id="userDao" class="com.test.dao.UserDao">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> //这个类是在spring的jar包中的，这样直接引用就能用
<property name="mappingResources"> //映射文件
<list>
<value>com / test / po / User.hbm.xml</value> //这里面放的是User.hbm.xml ,po的配置文件
</list>
</property>
<property name="hibernateProperties"> //全局参数
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
<prop key="hibernate.connection.url">jdbc:mysql://locahost:3306/test</prop>
<prop key="hibernate.connection.username">root</prop>
<prop key="hibernate.connection.password">1234</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
2.建包com.test.po，里面有User.java类和User.hbm.xml
User.java
public class User{
private SessionFactory sessionFactory;
public SessionFactory getSessionFactory(){
return sessionFactory;
}
public void setSessionFactory(SessionFactory sessionFactory){
this.sessionFactory = sessionFactory;
}
public void add(User user){
Session session = sessionFactory.openSession();
session.beginTransaction();
session.save(user);
session.getTransaction().commint();
session.close();
}
}
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.po">
<class name="User" table="t_user" lazy="false" ><id name="id" column="id" >
<!-- 根据数据库本身的能力去选择 id生成方式。 -->
<generator class="native"></generator>
</id>
<property name="name" column="username" ></property>
<property name="phone" column="phone" ></property>
<property name="age" ></property>
</class>
</hibernate-mapping>
3.拷贝hibernate的jar包到自己的项目
antlr-2.7.6.jar
asm-attrs.jar
asm.jar
cglib-2.1.3.jar
commons-collections-2.1.1.jar
commons-logging-1.0.4.jar
dom4j-1.6.1.jar echache-1.2.jar
hibernate3.jar
jta.jar
mysql-connection-java-5.1.13.jar
4.Test.java
public class Test{
public static void main(String[] args){
ApplicationContext ac = new ClassPathXmlApplicationContext(
new String[]{"applicationContext.xml"}
);
UserDao dao = (UserDao) ac.getBean("userDao");
User user = new User("xiaogao","123",12);
dao.add(user);
}
}
5.运行Test.java，如果可以在数据库中生成t_user表，并且里面有xiaogao的信息，说明spring和hibernate整合成功
6.在spring和hibernate整合好的基础上，然后再把spring和struts2整合的部分加进来，测试一下看看能不能通过action给数据库传参数进去。挺重要的，会了这个，就会这三大框架的
整合开发
a) 步骤就不写了，上面有个spring和struts整合的步骤
b) UserAction.java里
public class UserAction{
private UserDao userDao;
public UserDao getUserDao(){
return userDao;
}
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
private User user;
public User getUser(){
return user;
}
public void setUser(User user){
this.user = user;
}
public String add(){
userDao.add(user);
return null;
}
}
7.启动项目，访问http://localhost:8080/项目名/userAction!add?user.name=cai10，访问后看看数据库中有没有添加名字为cai10的信息，有则三大框架整合成功！！！！！！！！！
以上只是最基本的整合，数据库连接池没加，事务管理没加，hibernateTemplate没使用，opensession没使用，这四个是spring给hibernate提供的辅助功能。
三大框架整合end———————————————————
—————HibernateTemplate———————
HibernateTemplate简化DAO的编写，甚至可以代替DAO层，它是由spring提供的。因为它包装了dao，所以在用的时候需要往里面传入sessionFactory（SessionFactory是连接数据库的，所以传入SessionFactory后它就具备了连接数据库的能力）
1.用HibernateTemplate的时候，需要在applicationContext.xml配置文件中增加：
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--txManager管理事务的开启和关闭-->
<bean id="txManager" class="org.springframework.orm.hibernate3.hibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--开启annotation方式的事务管理-->
<tx:annotation-driven transaction-manager="txManager"/>
2.以前的dao，需要创建Session关闭Session，开启事物、关闭事物（事务是指opensession）。这些话是重复的，HibernateTemplate把这几句话封装起来了UserAction.java重新写，不使用UserDao了，用HibernateTemplate（它就相当于一个BaseDao，或者一个公共的DAO对象）
public class UserAction{
private User user;
public User getUser(){
retrun user;
}
public void setUser(User user){
this.user = user;
}
private HibernateTemplete hibernateTemplate;
public HibernateTemplate getHibernateTemplate(){
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate){
this.hibernateTemplate = hibernateTemplate;
}
@Transactional
public String add(){
hibernateTemplate.save(user); //一个save方法满足了原来的5行代码
//hibernateTemplate.delete(entity); //删除
//hibernateTemplate.update(entity);
//hibernateTemplate.find("from User"); //from User是一个hql语句，被hibernateTemplate包装后的查询很简单，放入hql语句，就能返回一个List
//平时的CRUD变成了hibernateTemplate的这四句话。
return null;
}
//这个方法测试时可以关闭或打开，查询所有
public String findAll(){
List<User> list = hibernateTemplate.find("from User");
for(Iterator iterator = list.iterator(); iterator.hasNext();){
User user = (User) iterator.next();
System.out.println(user.getName()+"--"+user.getId());
}
return null;
}
private String name;
public String findByCondition(){
List<User> list = hibernateTemplate.find("from User u where u.name=?",new Object[]{name}); //逗号后的值对应前面那个问号
for(Iterator iterator = list.iterator();iterator.hasNext();){
User user = (User) iterator.next();
System.out.println(user.getName());
}
return null;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
技巧：报空指针时，先找报错那行的点，点前面的对象肯定没创建。！！！
3.在applicationContext.xml中增加
<bean id="userAction" class="com.bjsxt.action.UserAction" scope="prototype">
<property name="hibernateTemplate" ref="hibernateTemplate"></property>
</bean>
4.写user类
public class User{
private Integer id;
private String name;
private String phone;
private Integer age;
public User(String name,String phone,Integer age){
super();
this.name = name;
this.phone = phone;
this.age = age;
}
public User(){
super();
}
public Integer getId(){
return id;
}
public void setId(Integer id){
this.id = id
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name
}
public String getPhone(){
return phone;
}
public void setPhone(String phone){
this.phone = phone;
}
public Integer getAge(){
return age;
}
public void setAge(Integer age){
this.age = age;
}
}
5.写测试类Test.java
public class Test{
public static void main(String[] args){
ApplicationContext ac = new ClassPathXmlApplicationContext(
new String[]{"applicationContext.xml"}
);
UserAction userAction = (UserAction) ac.getBean("userAction");
System.out.println(userAction.getClass().getName());
//测试时这段代码可根据情况注释掉
User user = new User();
user.setName("xiaogao");
userAction.setUser(user);
userAction.add();
userAction.setName("xiaogao");
userAction.findByCondition();
}
}
**Spring对hibernate的事务有单独的切面管理
———————hibernateTemplate end———————————————————————————————