三大框架整合原理及详解<一>

问题？三大框架整合原理及详解

提示：myeclipse环境、工程环境、tomcat环境的jdk保持一致（在这里我所使用的而是jdk1.6版本)



在这里我们调成1.6，并点击确定。

cmd:java -version :查看jdk的版本

1.新建一个工程，把工程的编码为utf-8

2.首先是三大框架所需要的jar包,把jar包放入到工程中的lib下(下载链接：点击下载jar包链接)

注意：MyEclisp可以把jar包放在lib下的文件夹下，但是eclipse就不可以，只能把jar包放在根目录下

3.整体结构图：



4.建立三个folder：

src 存放源代码

config 存放配置文件

hibernate 存放hibernate的配置文件

spring 存放spring的配置文件(在这里可以写固定不变的配置信息和需要变化的配置信息)

struts 存放struts的配置文件(这些里面的配置文件要引入到struts.xml中)

struts.xml(这个必须要在根目录下)

test 存放单元测试

5、在src下建立包

在实体类bean中写(这里写的 cn.itcast.s2sh.domain)持久化类和映射文件及hibernate配置文件
持久化类：

package cn.itcast.s2sh.domain;

import java.io.Serializable;

public class Person implements Serializable{
private Long pid;
private String pname;
private String psex;

public Person(){}

public Person(String pname){
this.pname = pname;
}

public Long getPid() {
return pid;
}
public void setPid(Long pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
public String getPsex() {
return psex;
}
public void setPsex(String psex) {
this.psex = psex;
}

}

映射文件：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--
用来描述一个持久化类
name  类的全名
table 可以不写  默认值和类名一样
catalog  数据库的名称  一般不写
-->
<class name="cn.itcast.s2sh.domain.Person">
<!--
标示属性  和数据库中的主键对应
name  属性的名称
column 列的名称
-->
<id name="pid" column="pid" length="200" type="java.lang.Long">
<!--
主键的产生器
就该告诉hibernate容器用什么样的方式产生主键
-->
<generator class="increment"></generator>
</id>
<!--
描述一般属性
-->
<property name="pname" column="pname" length="20" type="string">
</property>

<property name="psex" column="psex" length="10" type="java.lang.String"></property>
</class>
</hibernate-mapping>

在这里采用的是有持久化类和映射文件来产生数据库表。前提得把数据库建立起来(要求是编码格式为：)



hibernate.cfg.xml配置文件

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<!--
一个session-factory只能连接一个数据库
-->
<session-factory>
<!--
数据库的用户名
-->
<property name="connection.username">root</property>
<!--
密码
-->
<property name="connection.password">root</property>
<!--
url
-->
<property name="connection.url">jdbc:mysql://localhost:3306/ssh1</property>

<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>

<!-- 方言
告诉hibernate链接的mysql数据库 -->

<property name="hibernate.dialect">
org.hibernate.dialect.MySQLInnoDBDialect
</property>
<!--
当启动hibernate容器的时候，hibernate对表的处理情况
validate  验证表的结构，但是不会去创建表  默认值
update    如果表不存在，则创建，如果存在，则验证更新
create-drop 启动时创建表，应用程序结束时，销毁表
-->
<property name="hbm2ddl.auto">update</property>
<!--
显示sql语句
-->
<property name="show_sql">true</property>
<mapping resource="cn/itcast/s2sh/domain/Person.hbm.xml" />

</session-factory>
</hibernate-configuration>

其中;<property name="connection.driver_class">

com.mysql.jdbc.Driver

</property>

如果不写的话，可能会出现这个错误及解决办法：点击打开链接

6、编写dao层和service层

dao接口层和实现层

package cn.itcast.s2sh.dao;

import java.io.Serializable;

import cn.itcast.s2sh.domain.Person;

public interface PersonDao {
public void savePerson(Person person);
public Person personById(Serializable id);
}

package cn.itcast.s2sh.dao.Impl;

import java.io.Serializable;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import cn.itcast.s2sh.dao.PersonDao;
import cn.itcast.s2sh.domain.Person;

public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {

public void savePerson(Person person) {
this.getHibernateTemplate().save(person);
}

public Person personById(Serializable id) {
return (Person)this.getHibernateTemplate().load(Person.class, id);
//this.getHibernateTemplate().get(Person.class, id);
//这也可以实现，不过上面是采用懒加载的方式，减小内存压力
}

}

service接口层和实现层

package cn.itcast.s2sh.service;

import java.io.Serializable;

import cn.itcast.s2sh.domain.Person;

public interface PersonService {
public void savePerson(Person person);
public Person personById(Serializable id);
}

package cn.itcast.s2sh.service.Impl;

import java.io.Serializable;

import cn.itcast.s2sh.dao.PersonDao;
import cn.itcast.s2sh.domain.Person;
import cn.itcast.s2sh.service.PersonService;

public class PersonServiceImpl implements PersonService {
private PersonDao personDao;

public PersonDao getPersonDao() {
return personDao;
}

public void setPersonDao(PersonDao personDao) {
this.personDao = personDao;
}

public void savePerson(Person person) {
// TODO Auto-generated method stub
this.personDao.savePerson(person);
}

public Person personById(Serializable id) {
// TODO Auto-generated method stub
return this.personDao.personById(id);
}

}

7、写spring的配置文件

(1)、写sessionFactory



applocation-db.xml

<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: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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> 
<!-- 引入sessionfactory数据源 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate/hibernate.cfg.xml</value>
</property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>

<tx:advice id="tx" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" read-only="false"/>
<tx:method name="delete*" read-only="false"/>
<tx:method name="update*" read-only="false"/>
<!--
* 代表了除了上述的三种情况的以外的情况
-->
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut expression="execution(* cn.itcast.s2sh.service.Impl.*.*(..))" id="perform"/>
<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
</aop:config>
</beans>

(2)、测试sessionfactory

工具类读取applicationContext.xml配置文件：

package cn.itcast.s2sh.util;

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

public class SpringInit {
public static ApplicationContext applicationContext;
static{
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
}
}

测试类：

package cn.itcast.s2sh.test;

import org.junit.Test;

import cn.itcast.s2sh.util.SpringInit;

public class SessionFactory extends SpringInit{
@Test
public void testBuildSessionfactory(){
applicationContext.getBean("sessionFactory");
}
}

结果出现这个就意味着，你的seesionfactory成功了,并且查看数据库，可以看见生成数据库表了：



(3)、在application-person.xml中注入dao和service

<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: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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- dao层 -->
<bean id="personDao" class="cn.itcast.s2sh.dao.Impl.PersonDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<!-- service层 -->
<bean id="personService" class="cn.itcast.s2sh.service.Impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>

</beans>

(4)、测试

package cn.itcast.s2sh.test;

import org.junit.Test;

import cn.itcast.s2sh.action.PersonAction;
import cn.itcast.s2sh.domain.Person;
import cn.itcast.s2sh.service.PersonService;
import cn.itcast.s2sh.util.SpringInit;

public class PersonTest extends SpringInit {
@Test
public void personDaoTest(){
PersonService personService = (PersonService)applicationContext.getBean("personService");
Person person = new Person();
person.setPname("李大鹏");
person.setPsex("男");
personService.savePerson(person);
} }

结果出现如下，说明dao层到service层没问题：



8、写action层

package cn.itcast.s2sh.action;

import java.io.Serializable;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

import cn.itcast.s2sh.domain.Person;
import cn.itcast.s2sh.service.PersonService;

/**
* @author ActionSupport
* 这个就是struts走的方法包
*
*/
public class PersonAction extends ActionSupport {
private PersonService personService;

public PersonService getPersonService() {
return personService;
}

public void setPersonService(PersonService personService) {
this.personService = personService;
}

public String savePerson(){
Person person = new Person();
person.setPname("李大鹏3");
person.setPsex("男");
this.personService.savePerson(person);
return SUCCESS;
//StrutsSpringObjectFactory
}

public String showPersonById(){
Person person = this.personService.personById(1L);
//ActionContext.getContext().getValueStack().push(person);
ActionContext.getContext().put("person", person);
ServletActionContext.getRequest().setAttribute("person", person);
return "index";
}
}

9、写spring的配置文件

把action注入到spring容器中application-perosn.xml

<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: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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- dao层 -->
<bean id="personDao" class="cn.itcast.s2sh.dao.Impl.PersonDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<!-- service层 -->
<bean id="personService" class="cn.itcast.s2sh.service.Impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>
<!-- action层  这个要写成多例模式(于此同时，spring就不负责该对象产生的方法的生命周期了)-->
<bean id="personAction" class="cn.itcast.s2sh.action.PersonAction" scope="prototype">
<property name="personService">
<ref bean="personService"/>
</property>
</bean>
</beans>

scope为"prototype"保证了action的多实例

这个多例很重要，在多用户并发的时候起着很重要的作业，bean默认情况下产生的是单例

写struts.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
"http://struts.apache.org/dtds/struts-2.1.7.dtd">
<struts>
<constant name="struts.devMode" value="true"/>
<package name="person" namespace="/" extends="struts-default">
<!-- class="personAction" 与spring容器中bean相一致 -->
<action name="personAction_*" method="{1}" class="personAction">
<result name="success">index.jsp</result>
<result name="index">index1.jsp</result>
</action>
</package>
</struts>

10、在web.xml

加入spring的监听器

加入struts2的过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> 
<!-- 整合Spring -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/applicationContext.xml</param-value>
</context-param>

<!-- 配置Spring的OpenSessionInViewFilter，以解决懒加载异常
这个只能放在中间。，它的作用是解决懒加载关闭session的问题，
session.load()方式是要在得到属性的时候才发出sql语句，然后我们得到sql语句的时候是在jsp页面
那个时候session已经关闭了，所以需要打开session，在finally的时候关闭session
-->
<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>

<!-- struts2过滤器 -->
<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>

<display-name></display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

spring监听器：

如果是吧applicationContext.xml文件放在WEB-INF下，就不用管<param-name>名字了，因为默认会在该目录下找到。如果不是就需要默认起这个名字，然后并给它路径。

解释：



其中的OpenSessionInViewFilter，这个要重点讲一下，这个是为了处理懒加载的问题，在前面dao层中得到数据是load方法，这样的话它就会在get属性的时候，才发出sql语句，而得到属性的时候，已经是response到jsp的时候，那个session已经关闭了。我们就需要opensessionInViewFiter来推迟session的关闭时间.而且这个必须加载struts的上面也就是放在中间：

原因如下：

OpenSessionInView模式的运行方向： OpenSessionInView在第一个位置，struts2的过滤器在第二个位置



不加出现的错误：



优缺点：OpensessinInview虽然解决了懒加载的问题，但是却造成了session关闭时间推迟了，导致内存中的缓存数据长时间停留。

11、请求

index1.jsp

<body>
<%@ taglib uri="/struts-tags" prefix="s" %>
This is my JSP page. <br>
${requestScope.person.pname }<!-- ServletActionContext.getRequest().setAttribute("person", person); -->
<s:debug></s:debug>
</body>

测试：



最后三大框架搭建成功。案例下载链接