Java开发的应该如何掌握上述相关技术？
一：首先，有这样的一种情况很常见，对于想自学Java开发的人来说，他们
大多数都是非常盲目的，不知道自己改如何入手，很多人在网上找一些视频，然后疯狂的过视频，很快就把一块内容都学完，他们理解的学完了就是视
频看完了，但是让他们动手去做东西却做不出来，而我的理解学完了就是自己能写出东西，所以对于初学者来说一定不能盲目，要有自己的规划，不然
就是浪费时间白忙活。
二：既然是学习Java开发专业技术，我个人的建议是，一定要有一个能指导
你的人，不能都靠自己闭门造车，这样的行为并不聪明，结识一位这方面的人才，时不时去问问人家问题，不然你可能会发现一个小问题能困扰你一天
，**后还不知道是什么原因。
三：学习Java开发技术，不能跟学数学语文一样对待，比较刚接触代码是不
容易记住的，所以要掌握上述的技术，你还要知道学习Java开发技术有哪些“坑”。对于学习方法这块是尤为重要的，怎么学才能让你学完了能记住之
前学的那些，不至于学完了就忘，这个问题值得你学习之前去思考的。
四：根据我多年的学习情况来看，你平时一定要养成好的学习习惯，就说我
自己吧！我就喜欢把自己曾经遇到的问题整理在电脑的日记本上，然后我会搜集一下博客相关的Java技术文章，一些我认为比较有用的网站，以后都能
用的上，这是我个人的学习习惯，相信我，如果你想走的更远，一定要养成习惯。
**后给大家一些详细的学习安排路线：
Java基础：Java基础语法、数组、类与对象、继承与多态、异常、范型、集
合、流与文件、反射、枚举、自动装箱和注解。
数据库：mysql、oracle
Javaweb：HTML与CSS网页开发基础、Java脚本语言、搭建开发环境、JSP基
本语法、JSP内置对象、JavaBean技术、Servlet技术、Ajax技术
框架：Struts2、Hibernate、Spring、SpringMVC、mybatis
.数据库关键技术
-
01Mysql 基础
-
1.Mysql的安装和使用
-
2.图解Mysql程序结构
-
3.Mysql服务器的配置
-
4.Mysql 客户端使用
-
5.用户权限管理
-
6.Mysql数据库的使用
-
02SQL基础
-
1.SQL语句的三种类型
-
2.DML、DDL、DCL的应用
-
3.数据处理
-
4.子查询
-
5.创建和管理表
-
6.约束与分页
-
03JDBC
-
1.JDBC概述
-
2.获取数据库连接
-
3.数据库连接池C3P0 与 DBCP
-
4.使用JDBC 完成数据库DML操作
-
5.大数据的操作
-
6.批量处理与元数据
-
04DBUtils
-
1.使用QueryRunner
-
2.可插拔式结果集处理
-
3.批量处理
-
4.大数据结果集处理
-
5.自定义结果集处理
-
6.利用DBUtils编写通用 DAO
SSH框架整合——基于XML配置文件
>
SSH框架整合——基于xml配置文件
@(SPRing)[spring, struts2, hibernate, 框架整合, ssh, Spring]
SSH框架整合基于XML配置文件
SSH框架整合
SSH框架整合的基本环境准备
**步创建web项目引入jar包
第二步引入框架的配置文件
第三步创建包结构和类
第四步将Service和DAO交给Spring管理
第五步引入页面
SSH整合Struts2和Spring的整合
第六步修改页面链接为Struts2所能匹配的格式
第七步编写Action中的listCustomer方法
第八步Struts2和Spring整合方式一Action由Struts2自身创建
第八步Struts2和Spring整合方式二Action交给Spring管理推荐
第九步在客户Service中使用客户Dao
SSH整合Hibernate和Spring的整合
第十步Hibernate和Spring整合方式一带hibernate的配置文件
第十步Hibernate和Spring整合方式二不带hibernate的配置文件推荐
第十一步添加事务管理
Hibernate的模板的API
使用Hibernate的模板完成CRUD的操作
完成增删改的操作
完成查询的操作
配置opensessionInView过滤器解决Hibernate懒加载问题
配置全站编码过滤器
SSH框架整合
该SSH整合是基于Spring4、Struts2、Hibernate5的。
SSH框架整合的基本环境准备
**步：创建web项目，引入jar包
标红为整合必须引入的
Struts2
struts-2.3.24\apps\struts2-blank\WEB-INF\lib*.jar —Struts2基本开发包 struts2-convention-plugin-2.3.24.jar —Struts2的注解开发包
struts2-spring-plugin-2.3.24.jar —Struts2整合Spring的开发包 struts2-json-plugin-2.3.24.jar —Struts2整合Ajax的开发包
javax.servlet.jsp.jstl-1.2.1.jar — java标准标签库
Hibernate
MySQL-connector-java-5.1.7-bin.jar —数据库驱动 hibernate-release-5.0.7.Final\lib\required*.jar —Hibernate必须包 日志记录
c3p0连接池
注意：在struts2基础包和Hibernate5基础包中javassist-x.jar这个包会有冲突，搭环境时请使用Hibernate中的高版本javassist的包
Spring
Spring的基本开发包 Spring的AOP的开发包 Spring整合web项目包：spring-web-4.2.4.RELEASE.jar Spring整合Junit项目包 spring-test-4.2.4.RELEASE.jar junit-4.9.jar Spring的JDBC模板包：spring-jdbc-4.2.4.RELEASE.jar Spring事务管理包：spring-tx-4.2.4.RELEASE.jar Spring整合Hibernate：spring-orm-4.2.4.RELEASE.jar 整合c3p0连接池：com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar，需要使用c3p0连接池，可以导入。
如果使用有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用hibernate中c3p0可选包中的三个jar包；
如果使用没有hibernate配置文件的ssh整合，使用c3p0连接池，需要使用spring整合c3p0连接池中的jar包。
两者不可同用，否则会有冲突。
第二步：引入框架的配置文件
Struts2
web.xml
<!-- Struts核心过滤器 -->
<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>
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>
</struts>
Hibernate
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>
</session-factory>
</hibernate-configuration>
映射文件
<?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="">
</hibernate-mapping>
Spring
web.xml
<!-- 配置Spring上下文环境 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
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"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.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">
</beans>
log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change info to debug ###
log4j.rootLogger=info, stdout
第三步：创建包结构和类
package com.pc.crm.domain;
import java.io.Serializable;
/**
* 客户实体类
* @author Switch
*/
public class Customer implements Serializable {
private static final long serialVersionUID = 8501538130746309236L;
}
package com.pc.crm.web.action;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.pc.crm.domain.Customer;
/**
* 客户Action
* @author Switch
*/
public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
private static final long serialVersionUID = 7878143682430064108L;
Customer customer = new Customer();
@Override
public Customer getModel() {
return this.customer;
}
}
package com.pc.crm.service;
/**
* 客户服务接口
* @author Switch
*/
public interface CustomerService {
}
package com.pc.crm.service.impl;
import com.pc.crm.service.CustomerService;
/**
* 客户服务实现类
* @author Switch
*/
public class CustomerServiceImpl implements CustomerService {
}
package com.pc.crm.dao;
/**
* 客户持久层接口
* @author Switch
*/
public interface CustomerDao {
}
package com.pc.crm.dao.impl;
import com.pc.crm.dao.CustomerDao;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl implements CustomerDao {
}
第四步：将Service和DAO交给Spring管理
<!-- 配置客户服务bean -->
<bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl">
</bean>
<!-- 配置客户持久层bean -->
<bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl">
</bean>
第五步：引入页面
这里只给出一个访问链接，基于JSP的。
<a href="${pageContext.request.contextPath}/customer/listCustomer">客户列表</a>
SSH整合：Struts2和Spring的整合
第六步：修改页面链接为Struts2所能匹配的格式
<a href="${pageContext.request.contextPath}/customer/list_Customer.action">客户列表</a>
第七步：编写Action中的listCustomer方法
package com.pc.crm.web.action;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.pc.crm.domain.Customer;
import com.pc.crm.service.CustomerService;
/**
* 客户Action
* @author Switch
*/
public class CustomerAction extends ActionSupport implements ModelDriven<Customer> {
private static final long serialVersionUID = 7878143682430064108L;
// 客户服务类
CustomerService customerService;
// 用于使用值栈特性，在页面中使用
List<Customer> customers = null;
public List<Customer> getCustomers() {
return customers;
}
public void setCustomers(List<Customer> customers) {
this.customers = customers;
}
// 模型驱动
Customer customer = new Customer();
@Override
public Customer getModel() {
return this.customer;
}
/**
* 显示客户列表
* @return
*/
public String listCustomer() {
// 从数据库中获客户列表
customers = customerService.findAllCustomer();
// 转发到客户列表视图
return "list";
}
}
第八步：Struts2和Spring整合方式一：Action由Struts2自身创建
引入Struts2和Spring整合的插件包
struts2-spring-plugin-2.3.24.jar
该jar包下有一个struts-plugin.xml的文件，在该文件中开启了Spring工厂对Action中的属性按照名称自动装配等功能。
<!-- Make the Spring object factory the automatic default -->
<constant name="struts.objectFactory" value="spring" />
该常量在struts2核心包的default.properties文件中，有如下配置
### 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
### indicates to the struts-spring integration if Class instances should be cached
### this should, until a future Spring release makes it possible, be left as true
### unless you know exactly what you are doing!
### valid values are: true, false (true is the default)
struts.objectFactory.spring.useClassCache = true
### ensures the autowire strategy is always respected.
### valid values are: true, false (false is the default)
struts.objectFactory.spring.autoWire.alwaysRespect = false
### By default SpringObjectFactory doesn t support AOP
### This flag was added just temporally to check if nothing is broken
### See https://issues.apache.org/jira/browse/WW-4110
struts.objectFactory.spring.enableAopSupport = false
当struts.objectFactory常量启用时，开启对Spring的一系列支持。比如说按名自动装配。
在Action中不需要使用原来的工厂获取，提供set方法即可。
// 注入客户服务类
CustomerService customerService;
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
/**
* customerService未优化
*/
/* public CustomerAction() {
ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
customerService = context.getBean("customerService", CustomerService.class);
}
*/
配置Action：Action是Struts2自身创建
<package name="customer" extends="struts-default" namespace="/customer">
<!-- 形如list_Customer -->
<action name="*_*" class="com.pc.crm.web.action.CustomerAction" method="{1}{2}">
<!-- 转发到客户列表视图 -->
<result name="list" type="dispatcher">/jsp/customer/list.jsp</result>
</action>
</package>
第八步：Struts2和Spring整合方式二：Action交给Spring管理（推荐）
引入Struts2和Spring整合的插件包
struts2-spring-plugin-2.3.24.jar
将Action交给Spring创建
<!-- 配置Action，Action注入属性，必须手工注入，且必须声明为多例 -->
<!-- 客户Action -->
<bean id="customerAction" class="com.pc.crm.web.action.CustomerAction" scope="prototype">
<property name="customerService" ref="customerService" />
</bean>
注意的事项
一定要将Action配置为多例的
属性的注入必须手动完成
struts.xml文件中对应action的class属性为bean的id属性
<package name="customer" extends="struts-default" namespace="/customer">
<!-- 形如list_Customer -->
<action name="*_*" class="customerAction" method="{1}{2}">
<!-- 转发到客户列表视图 -->
<result name="list" type="dispatcher">/jsp/customer/list.jsp</result>
</action>
</package>
第九步：在客户Service中使用客户Dao
package com.pc.crm.service.impl;
import java.util.List;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
import com.pc.crm.service.CustomerService;
/**
* 客户服务实现类
* @author Switch
*/
public class CustomerServiceImpl implements CustomerService {
// 注入客户Dao
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
@Override
public List<Customer> findAllCustomer() {
// 查找客户列表
return customerDao.findAllCustomer();
}
}
<!-- 配置客户服务bean -->
<bean id="customerService" class="com.pc.crm.service.impl.CustomerServiceImpl">
<property name="customerDao" ref="customerDao"/>
</bean>
SSH整合：Hibernate和Spring的整合
第十步：Hibernate和Spring整合方式一：带hibernate的配置文件
创建实体类和映射文件
Customer.hbm.xml package com.pc.crm.domain;
import java.io.Serializable;
/**
* 客户实体类
* @author Switch
*/
public class Customer implements Serializable {
private static final long serialVersionUID = 8501538130746309236L;
private Long custId;
private String custName;
private String custSource;
private String custIndustry;
private String custLevel;
private String custAddress;
private String custPhone;
......
}
<?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="com.pc.crm.domain">
<class name="Customer" table="cst_customer" lazy="true" batch-size="3">
<id name="custId" column="cust_id" type="java.lang.Long">
<generator class="native"/>
</id>
<property name="custName" column="cust_name" type="java.lang.String" length="32"/>
<property name="custSource" column="cust_source" type="java.lang.String" length="32"/>
<property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/>
<property name="custLevel" column="cust_level" type="java.lang.String" length="32"/>
<property name="custAddress" column="cust_address" type="java.lang.String" length="128"/>
<property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/>
</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://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 1、连接数据库的基本信息 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mycrm</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.passWord">123456</property>
<!-- 数据库的方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 2、hibernate的基本配置 -->
<!-- 是否显示SQL语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 是否格式化显示SQL语句 -->
<property name="hibernate.format_sql">true</property>
<!-- 采用何种策略来创建表结构： -->
<!-- update：检查表结构和实体类映射文件的变化，如果发现映射文件和表结构不一致，更新表结构。 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置hibernate使用连接池：告知Hibernate使用连接池的厂商 -->
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<!-- 3、映射文件的位置 -->
<mapping resource="com/pc/crm/domain/Customer.hbm.xml" />
<mapping resource="com/pc/crm/domain/LinkMan.hbm.xml" />
</session-factory>
</hibernate-configuration>
在Spring中引入Hibernate的配置文件
<!-- 配置Hibernate的SessionFactory,有hibernate配置文件 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>
Spring为了简化Hibernate的开发，提供了Hibernate的模板
package com.pc.crm.dao.impl;
import java.util.List;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public List<Customer> findAllCustomer() {
}
}
<!-- 配置客户持久层bean -->
<bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl">
<!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
在客户Dao中使用Hibernate的模板
package com.pc.crm.dao.impl;
import java.util.List;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public List<Customer> findAllCustomer() {
return (List<Customer>) this.getHibernateTemplate().find("from Customer");
}
}
第十步：Hibernate和Spring整合方式二：不带hibernate的配置文件（推荐）
创建实体类和映射文件
Customer.hbm.xml package com.pc.crm.domain;
import java.io.Serializable;
/**
* 客户实体类
* @author Switch
*/
public class Customer implements Serializable {
private static final long serialVersionUID = 8501538130746309236L;
private Long custId;
private String custName;
private String custSource;
private String custIndustry;
private String custLevel;
private String custAddress;
private String custPhone;
......
}
<?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="com.pc.crm.domain">
<class name="Customer" table="cst_customer" lazy="true" batch-size="3">
<id name="custId" column="cust_id" type="java.lang.Long">
<generator class="native"/>
</id>
<property name="custName" column="cust_name" type="java.lang.String" length="32"/>
<property name="custSource" column="cust_source" type="java.lang.String" length="32"/>
<property name="custIndustry" column="cust_industry" type="java.lang.String" length="32"/>
<property name="custLevel" column="cust_level" type="java.lang.String" length="32"/>
<property name="custAddress" column="cust_address" type="java.lang.String" length="128"/>
<property name="custPhone" column="cust_phone" type="java.lang.String" length="64"/>
</class>
</hibernate-mapping>
替换
hibernate.cfg.xml中的相关内容，将其配置在spring中
提供数据库属性文件
db.properties jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mycrm
jdbc.user=root
jdbc.password=123456
配置属性持有对象
<!-- 配置属性持有对象 -->
<context:property-placeholder location="classpath:db.properties"/>
配置数据源
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
替换hibernate配置信息
<!-- 配置Hibernate的SessionFactory,无hibernate配置文件 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!-- 配置数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- 配置hibernate属性-->
<property name="hibernateProperties">
<props>
<!-- 数据库的方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 是否显示SQL语句 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 是否格式化显示SQL语句 -->
<prop key="hibernate.format_sql">true</prop>
<!-- 采用何种策略来创建表结构： -->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 配置映射文件 -->
<property name="mappingLocations" value="classpath:com/pc/crm/domain/*.hbm.xml"/>
</bean>
Spring为了简化Hibernate的开发，提供了Hibernate的模板
package com.pc.crm.dao.impl;
import java.util.List;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public List<Customer> findAllCustomer() {
}
}
<!-- 配置客户持久层bean -->
<bean id="customerDao" class="com.pc.crm.dao.impl.CustomerDaoImpl">
<!-- 该bean继承了HibernateDaoSupport，则可以直接注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
在客户Dao中使用Hibernate的模板
package com.pc.crm.dao.impl;
import java.util.List;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public List<Customer> findAllCustomer() {
return (List<Customer>) this.getHibernateTemplate().find("from Customer");
}
}
第十一步：添加事务管理
配置事务管理器
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
配置事务通知
<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 事务管理策略，查为只读 -->
<!-- 事务隔离级别：mysql为可重复读，事务传播行为：默认值required -->
<tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
<tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
<tx:method name="*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
</tx:attributes>
</tx:advice>
配置事务AOP
<!-- 配置事务AOP -->
<aop:config>
<aop:pointcut expression="execution(* com.pc.crm.service.impl.*.*(..))" id="pointcut1"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>
PS：如果需要配置基于注解的事务，请参考之前的博文《Spring事务管理》。
Hibernate的模板的API
使用Hibernate的模板完成CRUD的操作
完成增删改的操作
Serializable save(Object obj);
void update(Object obj);
void delete(Object obj);
package com.pc.crm.dao.impl;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public void save(Customer customer) {
this.getHibernateTemplate().save(customer);
}
@Override
public void update(Customer customer) {
this.getHibernateTemplate().update(customer);
}
@Override
public void delete(Customer customer) {
this.getHibernateTemplate().delete(customer);
}
}
完成查询的操作
T get(Class c,Serializable id); / T load(Class c,Serializable id);
List
package com.pc.crm.dao.impl;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.pc.crm.dao.CustomerDao;
import com.pc.crm.domain.Customer;
/**
* 客户持久层接口实现类
* @author Switch
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public Customer findById(Long id) {
return this.getHibernateTemplate().load(Customer.class, id);
}
@Override
public List<Customer> findAll() {
// 使用HQL查询:
// List<Customer> list = (List<Customer>) this.getHibernateTemplate().find("from Customer ");
// 使用QBC查询:使用DetchedCriteria
// DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
// List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
// 命名查询：
List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByNamedQuery("queryAll");
return list;
}
@Override
public List<Customer> findByPage() {
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
List<Customer> list = (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria, 0, 3);
return list;
}
}
配置openSessionInView过滤器，解决Hibernate懒加载问题
<!-- 配置openSessionInView，解决Hibernate懒加载问题 -->
<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
PS：将该过滤器放在Struts2核心过滤器上面。
配置全站编码过滤器
<!-- 配置全站编码过滤器 -->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!-- 编码 -->
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<!-- 是否强制使用该编码 -->
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
PS：将该过滤器放在Struts2核心过滤器上面。
相关推荐：
苏州JAVA培训 苏州JAVA培训班 苏州JAVA培训机构
个试听名额
