一、整合原理

二、导包(41个)

  1.hibernate

  (1)hibernate/lib/required

  

  (2)hibernate/lib/jpa | java persist api java的持久化规范(接口)

  

  (3)数据库驱动

  

  2.struts2

  (1)struts-blank.war/WEB-INF/lib/*

   注意:javassist-3.18.1-GA.jar包与hibernate中的重复(只保留高版本即可)

  

  (2)struts整合spring插件包

   注意:这个包一旦导入,那么struts2在启动时就会寻找spring容器.找不到将会抛出异常

  

  3.spring

  (1)基本:4+2

   core | beans | context | expression | logging | log4j

  (2)整合web:web包

   spring-web

  (3)整合aop:4个

   spring-aop | spring-aspect | aop联盟 | aopweaving

  (4)整合Hibernate和事务:4个

   spring-jdbc | spring-tx | c3p0 | spring-orm

  (5)整合junit4测试:test包

   spring-test

  4.标签库

   standard.jar | jstl-1.2.jar

三、单独配置spring容器

  1.创建applicationContext.xml,并导入约束(4个) beans | context | aop | tx

   

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd "> <bean name="userAction" class="cn.xyp.web.action.UserAction"></bean> </beans>

  2.配置spring随项目启动(web.xml)

  <!-- 让spring随web启动而创建的监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置spring配置文件位置参数 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

四、单独配置struts2

  1.配置struts2主配置文件(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="crm" namespace="/" extends="struts-default">
<action name="UserAction_*" class="cn.xyp.web.action.UserAction" method="{1}">
<result name="success">/success.jsp</result>
</action>
</package>
</struts>

  2.配置struts2核心过滤器到web.xml

  <!-- 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>

五、struts2与spring整合

  1.导包(已经导入)

   struts2-spring-plugin-2.3.24.jar

  2.配置常量

   查看默认配置文件从31行开始找到要配置的变量。

  

### if specified, the default object factory can be overridden here
### Note: short-hand notation is supported in some cases, such as "spring"
### Alternatively, you can provide a com.opensymphony.xwork2.ObjectFactory subclass name here
# struts.objectFactory = spring ### specifies the autoWiring logic when using the SpringObjectFactory.
### valid values are: name, type, auto, and constructor (name is the default)
struts.objectFactory.spring.autoWire = name

   添加常量到struts.xml

    <!-- #  struts.objectFactory = spring    将action的创建交给spring容器
struts.objectFactory.spring.autoWire = name spring负责装配Action依赖属性
-->
<constant name="struts.objectFactory" value="spring"></constant>

  3.整合方案1:struts2自己创建action,spring负责组装依赖属性(了解)

        <!-- 整合方案1:class属性上仍然配置action的完整类名
struts2仍然创建action,由spring负责组装Action中的依赖属性
-->
<action name="UserAction_*" class="cn.xyp.web.action.UserAction" method="{1}" >
<result name="toHome" type="redirect" >/index.htm</result>
<result name="error" >/login.jsp</result>
</action>

   不推荐理由:最好由spring完整管理action的生命周期.spring中功能才应用到Action上.

  4.整合方案2:spring负责创建action以及组装.(推荐)

   applicationContext.xml:

    <!-- action -->
<!-- 注意:Action对象作用范围一定是多例的.这样才符合struts2架构 -->
<bean name="userAction" class="cn.itcast.web.action.UserAction" scope="prototype" >
<property name="userService" ref="userService" ></property>
</bean>

   struts.xml:

         <!--
整合方案2:class属性上填写spring中action对象的BeanName
完全由spring管理action生命周期,包括Action的创建
注意:需要手动组装依赖属性
-->
<action name="UserAction_*" class="userAction" method="{1}" >
<result name="toHome" type="redirect" >/index.htm</result>
<result name="error" >/login.jsp</result>
</action>

六、单独配置hibernate

  1.导入实体类&orm元数据

  

   举例:User.java

package cn.xyp.web.domain;

import java.util.HashSet;
import java.util.Set; public class User {
private Long user_id;
private String user_code;
private String user_name;
private String user_password;
private Character user_state;
public Long getUser_id() {
return user_id;
}
public void setUser_id(Long user_id) {
this.user_id = user_id;
}
public String getUser_code() {
return user_code;
}
public void setUser_code(String user_code) {
this.user_code = user_code;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getUser_password() {
return user_password;
}
public void setUser_password(String user_password) {
this.user_password = user_password;
}
public Character getUser_state() {
return user_state;
}
public void setUser_state(Character user_state) {
this.user_state = user_state;
}
@Override
public String toString() {
return "User [user_id=" + user_id + ", user_code=" + user_code + ", user_name=" + user_name + ", user_password="
+ user_password + "]";
}
}

   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 package="cn.xyp.domain" >
<class name="User" table="sys_user" >
<id name="user_id" >
<generator class="native"></generator>
</id>
<property name="user_code" ></property>
<property name="user_name" ></property>
<property name="user_password" ></property>
<property name="user_state" ></property> </class>
</hibernate-mapping>

  2.配置主配置文件(hibernate.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> <!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql:///crm_32</property>
<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库连接密码 -->
<property name="hibernate.connection.password">1234</property>
<!-- 数据库方言
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>
<!--
自动导出表结构. 自动建表
-->
<property name="hibernate.hbm2ddl.auto">update</property> <!-- 引入实体配置文件 -->
<mapping resource="cn/xyp/domain/Customer.hbm.xml" />
<mapping resource="cn/xypt/domain/LinkMan.hbm.xml" />
<mapping resource="cn/xyp/domain/User.hbm.xml" /> </session-factory>
</hibernate-configuration>

七、spring整合hibernate

  1.整合原理

   将sessionFactory对象交给spring容器管理

  2.在spring中配置sessionFactory

  (1)配置方案一:(了解)

    <!-- 加载配置方案1:仍然使用外部的hibernate.cfg.xml配置信息 -->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
<property name="configLocation" value="classpath:hibernate.cfg.xml" ></property>
</bean>

  (2)配置方案二:(推荐)

    <!-- 加载配置方案2:在spring配置中放置hibernate配置信息 -->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
<!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
<property name="dataSource" ref="dataSource" ></property>
<!-- 配置hibernate基本信息 -->
<property name="hibernateProperties">
<props>
<!-- 必选配置 -->
<prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
<prop key="hibernate.connection.url" >jdbc:mysql:///crm_32</prop>
<prop key="hibernate.connection.username" >root</prop>
<prop key="hibernate.connection.password" >1234</prop>
<prop key="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</prop> <!-- 可选配置 -->
<prop key="hibernate.show_sql" >true</prop>
<prop key="hibernate.format_sql" >true</prop>
<prop key="hibernate.hbm2ddl.auto" >update</prop>
</props>
</property>
<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:cn/itcast/domain" ></property>
</bean>

八、spring整合c3p0连接池

  1.配置db.properties

jdbc.jdbcUrl=jdbc:mysql:///xyp_crm
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456

  2.引入连接池到spring中

    <!-- 读取db.properties文件 -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 配置c3p0连接池 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
<property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
<property name="driverClass" value="${jdbc.driverClass}" ></property>
<property name="user" value="${jdbc.user}" ></property>
<property name="password" value="${jdbc.password}" ></property>
</bean>

  3.将连接池注入给SessionFactory

    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
<!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
<property name="dataSource" ref="dataSource" ></property>

九、spring整合hibernate环境操作数据库

  1.Dao类创建:继承HibernateDaoSupport

   注意:项目中要确保使用统一版本。

  

//HibernateDaoSupport 为dao注入sessionFactory
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

  2.hibernate模板的操作

  (1)execute

    @Override
public User getByUserCode(final String usercode) {
//HQL
return getHibernateTemplate().execute(new HibernateCallback<User>() {
@Override
public User doInHibernate(Session session) throws HibernateException {
String hql = "from User where user_code = ? ";
Query query = session.createQuery(hql);
query.setParameter(0, usercode);
User user = (User) query.uniqueResult();
return user;
}
});

  (2)findByCriteria

        //Criteria
DetachedCriteria dc = DetachedCriteria.forClass(User.class); dc.add(Restrictions.eq("user_code", usercode)); List<User> list = (List<User>) getHibernateTemplate().findByCriteria(dc); if(list != null && list.size()>0){
return list.get(0);
}else{
return null;
}

  3.spring中配置dao

    <!-- Dao -->
<bean name="userDao" class="cn.xyp.dao.impl.UserDaoImpl" >
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>

十、spring的aop事务

  1.准备工作

    <!-- 核心事务管理器 -->
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager" >
<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>

  2.xml配置aop事务

  (1)配置通知

    <!-- 配置通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager" >
<tx:attributes>
<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
<tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
</tx:attributes>
</tx:advice>

  (2)配置织入

    <!-- 配置将通知织入目标对象
配置切点
配置切面 -->
<aop:config>
<aop:pointcut expression="execution(* cn.itcast.service.impl.*ServiceImpl.*(..))" id="txPc"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config>

  3.注解配置aop事务

  (1)开启注解事务

    <!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />

  (2)Service类中使用注解

@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=true)
public class UserServiceImpl implements UserService{
    @Override
@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
public void saveUser(User u) {
ud.save(u);
}

十一、扩大session作用范围

  1.配置filter

   为了避免使用懒加载时出现no-session问题.需要扩大session的作用范围。

  <!-- 扩大session作用范围
注意: 任何filter一定要在struts的filter之前调用
因为struts是不会放行的
-->
<filter>
<filter-name>openSessionInView</filter-name>
<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter> <filter-mapping>
<filter-name>openSessionInView</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

十二、练习:用户登录

  1.struts.xml核心配置

<struts>
<!-- # struts.objectFactory = spring 将action的创建交给spring容器
struts.objectFactory.spring.autoWire = name spring负责装配Action依赖属性
-->
<constant name="struts.objectFactory" value="spring"></constant> <package name="crm" namespace="/" extends="struts-default" >
<global-exception-mappings>
<exception-mapping result="error" exception="java.lang.RuntimeException"></exception-mapping>
</global-exception-mappings> <!--
整合方案:class属性上填写spring中action对象的BeanName
完全由spring管理action生命周期,包括Action的创建
注意:需要手动组装依赖属性
-->
<action name="UserAction_*" class="userAction" method="{1}" >
<result name="toHome" type="redirect" >/index.htm</result>
<result name="error" >/login.jsp</result>
</action>
</package>
</struts>

  2.Action代码

public class UserAction extends ActionSupport implements ModelDriven<User> {
private User user = new User(); private UserService userService ; public void setUserService(UserService userService) {
this.userService = userService;
} public String login() throws Exception {
//1 调用Service执行登陆逻辑
User u = userService.getUserByCodePassword(user);
//2 将返回的User对象放入session域
ActionContext.getContext().getSession().put("user", u);
//3 重定向到项目首页
return "toHome";
} @Override
public User getModel() {
return user;
} }

  2.Service核心代码

    public User getUserByCodePassword(User u) {
// 1 根据登陆名称查询登陆用户
User existU = ud.getByUserCode(u.getUser_code());
// 2 判断用户是否存在.不存在=>抛出异常,提示用户名不存在
if (existU == null) {
throw new RuntimeException("用户名不存在!");
}
// 3 判断用户密码是否正确=>不正确=>抛出异常,提示密码错误
if (!existU.getUser_password().equals(u.getUser_password())) {
throw new RuntimeException("密码错误!");
}
// 4 返回查询到的用户对象
return existU;
}

  3.Dao核心代码

    public User getByUserCode(final String usercode) {

        //Criteria
DetachedCriteria dc = DetachedCriteria.forClass(User.class);
dc.add(Restrictions.eq("user_code", usercode)); List<User> list = (List<User>) getHibernateTemplate().findByCriteria(dc); if(list != null && list.size()>0){
return list.get(0);
}else{
return null;
} }

JAVAEE——SSH三大框架整合(spring+struts2+hibernate)的更多相关文章

  1. Maven SSH三大框架整合的加载流程

    <Maven精品教程视频\day02视频\03ssh配置文件加载过程.avi;> 此课程中讲 SSH三大框架整合的加载流程,还可以,初步接触的朋友可以听一听. < \day02视频\ ...

  2. SSH框架之Spring+Struts2+Hibernate整合篇

    回顾 -Hibernate框架 ORM: 对象关系映射.把数据库表和JavaBean通过映射的配置文件映射起来, 操作JavaBean对象,通过映射的配置文件生成SQL语句,自动执行.操作数据库. 1 ...

  3. JavaWeb_(SSH)三大框架整合struts+hibernate+spring_Demo

    三大框架整合 一.SSH导包 二.书写Spring 三.书写Struts 四.整合Spring与Struts 五.书写(与整合)Hibernate.引入c3p0连接池并使用hibernate模板 六. ...

  4. SSH三大框架整合案例

    SSH三大框架的整合   SSH三个框架的知识点 一.Hibernate框架 1. Hibernate的核心配置文件 1.1 数据库信息.连接池配置 1.2 Hibernate信息 1.3 映射配置 ...

  5. SSH三大框架整合配置详解

    首先,三大框架整合,肯定是要导入相当多的jar包,这是不容置疑的!     这里就不一一列举了,直接截图吧:             (1) 基于配置文件的整合:        第一步:我们需要在we ...

  6. 关于ssh三大框架整合的碎碎念

    三大框架整合,无非就是一个导jar包,修改配置文件的过程.完了就没事了. 还是有很多细节性的问题 比如在spring中写applicationContext.xml文件时不提示: 解决方法如下: 如果 ...

  7. ssh三大框架整合

    spring+struts2+hibernate 参考1:数据库为oracle http://takeme.iteye.com/blog/1678268 参考2:数据库为mysql http://bl ...

  8. SSH程序框架之Spring与HIbernate整合

    spring整合hibernate 有两种方式 1.注解方式 2.xml方式实现 Spring整合Hibernate有什么好处? 1.由IOC容器来管理Hibernate的SessionFactory ...

  9. SSH三大框架整合配置详细步骤(3)

    5 配置Spring2.5 5.1 基础配置 1)        导入spring包.下载spring-framework-2.5.6并解压后,在spring-framework-2.5.6" ...

随机推荐

  1. jQuery.validate表单校验+bootstrap

    谈谈表单校验 这大概是一种惯例,学习前台后台最开始接触的业务都是用户注册和登录.现在社会坚持以人为本的理念,在网站开发过程同样如此.User是我们面对较多的对象,也是较核心的对象.最开始的用户注册和登 ...

  2. (中级篇 NettyNIO编解码开发)第六章-编解码技术

    基于Java提供的对象输入/输出流ObjectlnputStream和ObjectOutputStream,可以直接把Java对象作为可存储的字节数组写入文件,也可以传输到网络上.对程序员来说,基于J ...

  3. 论MySQL何时使用索引,何时不使用索引

    索引: 使用索引可快速访问数据库表中的特定信息.索引是对数据库表中一列或多列的值进行排序的一种结构,例如 employee 表的姓(name)列.如果要按姓查找特定职员,与必须搜索表中的所有行相比,索 ...

  4. (原创)foef注意事项

    原创内容,转载请标明原文地址 我们先来看下下面的代码 //获取文件大小 DWORD Get_File_Size(const char* m_FilePath) { unsigned long size ...

  5. MySQL数据目录更改及相关问题解决方案

    步骤相关 1.停掉MySQL服务 service mysql stop 2.把旧的数据目录/var/lib/mysql备份到新的数据目录/data/mysql cp /var/lib/mysql /d ...

  6. 在.NET Core中使用Irony实现自己的查询语言语法解析器

    在之前<在ASP.NET Core中使用Apworks快速开发数据服务>一文的评论部分,.NET大神张善友为我提了个建议,可以使用Compile As a Service的Roslyn为语 ...

  7. java基础(一章)

    java基础(一章) 1.            java是一种面向对象的高级编程语言. 2.            java包括:              javase(java基础)       ...

  8. cpp(第三章)

    1.使用{}初始化时,{}若为空则默认初始化为0,至于防范类型转化错误 2.int对计算机而言最为自然的长度,处理起来效率最高的长度.int可能是short(16位)也可能是long(32位),在知道 ...

  9. 在ROS中使用花生壳的域名服务

    ROS功能强大,也比较复杂,各个版本的脚本可能也大同小异,我现在使用的是6.37.3的版本. 添加Script 进入菜单System->Scripts. 点击加号,像图中这样,添加代码,我给这段 ...

  10. Spring学习(18)--- AOP基本概念及特点

    AOP:Aspect Oriented Programing的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序程序功能的统一维护的一种技术 主要的功能是:日志记录,性能统计,安全控制, ...