java web 整合开发王者归来学习总结

或者直接在struts.properties中禁用所有的自动追加特性

Struts.url.includeParams=none

第16章 struts2.x高级应用

17.1日期时间转换器

继承与DefaultTypeConverter类，实现convertValue接口，三种日期格式和两种时间格式放入数组内，然后根据输入数据的类型，循环调用每种格式转换，正确的返回值；

在配置文件xwork-conversion.properties中配置数据类型对应的转换器（或者在struts的action中配置convertor=“com.helloweenvsfei.struts2.convertor.DatatimeConvertor”,这样只能被该action使用）------输入界面输入提交信息给action-----struts截获请求查找配置文件中action将提交的数据（是string类型，通过配置的转换器转化为对应的时间日期类型）注入到action的属性中，-----根据提交时的方法名称convert调用方法convert（）-------返回success------action根据返回结果跳转到对应的jsp显示界面。

17.2ServletActionContext类

需包含import org.apache.struts2.SeveletActionContext；该类中包含request、Response、ServletContext等对象；

或者实现*Aware（ServletContextAware、ServletRequestAware、ServletResponseAware、SessionAware）接口来，并实现set*方法（session的方法是setSession(Map sessionValues),map表示内部存储的各种数据，），将数据注入action的属性中；

17.3validator校验数据

支持校验必须继承Validateable接口，actionsupport类就继承该接口；在package内添加校验配置文件，名称按照格式Action类名-validation.xml或者Action类名-Action别名-validation.xml;例如下：

!DOCTYPE validators PUBLIC

"-//OpenSymphony Group//XWork Validator 1.0//EN"

"http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">

true

请输入书籍名称

请输入书籍作者

1900-01-01

2200-01-01

客户端validator校验配置，标签添加validate=“true”属性；

或者通过注解来添加校验；

第18章 struts 标签

18.1struts2标签

统一包含在struts-tags-tld文件中，位于Struts-core-2.0.11.1.jar的META-INF中；

18.2ognl语言

（object-graph navigation language）是操作对象属性的语言，可以用#获取上下文的资源；

#parameters表示request提交的所有参数，#request表示request的所有属性；

流程

先action继承ServletContextAware、ServletRequestAware、SessionAware接口，定义对象属性，和set方法，execute（）方法设置对象的一些属性值；在ognlSUCCESS.jsp中直接通过显示值；

18.3控制标签

hello kuto

hello fvssd

hello other

第19章 struts2拦截器和文件上传

19.1 使用拦截器

面向切面的开发思想，把相对独立的代码抽象出来，如数据转换和数据校验，action在struts.xml中配置的时候，package中需要继承struts-default才能使用struts的拦截器，如下

Struts有很多现成的拦截器

Timer计时拦截器计算action执行的时间

class="com.helloweenvsfei.struts2.action.TimerAction">

/timerSuccess.jsp

Token防重复提交拦截器

class="com.helloweenvsfei.struts2.action.TokenAction">

//必须的，自动赋值拦截器集合

/tokenSuccess.jsp

/tokenInput.jsp

/tokenInvalid.jsp//失败跳转界面，必须

表单中要加一个标记，才会触发token拦截器；这个标记在Session中生成表单的唯一标示，提交一次后失效；

execAndWait执行等待拦截器显示等待页面

class="com.helloweenvsfei.struts2.action.WaitAction">

//完成后触发

等待触发

/waitSuccess.jsp

/waiting.jsp

自定义权限验证拦截器

自定义拦截器要继承interceptor接口或者abstractInterceptor抽象类，是一个java文件，需要实现intercept（ActionInvocation invocation）return invocation.invoke();表示继续调用action，否则权限不通过返回登陆界面return action.LOGIIN；定义好intercept类后需要在struts.xml中配置该拦截器，如下

class="com.helloweenvsfei.struts2.interceptor.AuthenticationInterceptor">

然后在需要使用该拦截器的action中配置该拦截器，与struts2的默认拦截器配置相同；

class="com.helloweenvsfei.struts2.action.AuthenticationAction">

/authenticationSuccess.jsp

19.2上传文件

Struts2文件封装在java.io.File中，需要定义一个对象用于接收表单上传的文件，struts2会将文件复制到一个临时文件夹中，以时间戳为名，后缀为|.tmp，避免重复，File属性保存的就是这个临时文件的路径加名字；要获取该文件的原始名称和原始属性，需要定义string类型的属性，命名格式为XXFileName和XXContentType，struts2会将原文件名和类型输入到这两个属性上;需要用循环写入的方式复制文件数据；

package com.helloweenvsfei.struts2.action;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class UploadAction extends ActionSupport {

private static final long serialVersionUID = -60950803930068947L;

private File picture;//定义file属性保存临时文件名

private String pictureContentType; //保存数据类型File对象名字+ContentType

private String pictureFileName;//保存文件的真实名字File对象名字+FileName

public String execute() {

return "input";

}

public String upload() throws Exception {

System.out.println("Context: "

+ ServletActionContext.getServletContext()

.getRealPath("upload"));

System.out.println("File: " + picture);

System.out.println("FileName: " + pictureFileName);

File saved = new File(ServletActionContext.getServletContext()

.getRealPath("upload"), pictureFileName);//创建保存的文件

InputStream ins = null;

OutputStream ous = null;

try {

saved.getParentFile().mkdirs();

ins = new FileInputStream(picture);

ous = new FileOutputStream(saved);

byte[] b = new byte[1024];

int len = 0;

while ((len = ins.read(b)) != -1) {//循环读取临时文件数据保存到服务器的文件中

ous.write(b, 0, len);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

if (ous != null)

ous.close();

if (ins != null)

ins.close();

}

return "list";

}

public File getPicture() {

return picture;

}

public void setPicture(File file) {

this.picture = file;

}

public String getPictureContentType() {

return pictureContentType;

}

public void setPictureContentType(String fileContentType) {

this.pictureContentType = fileContentType;

}

public String getPictureFileName() {

return pictureFileName;

}

public void setPictureFileName(String fileFileName) {

this.pictureFileName = fileFileName;

}

}

上传文件的设置

默认使用javax.servlet.context.tempdir作为工作目录，可以通过设置struts.multipart.saveDir属性修改目录，struts.multipart.maxSize来修改最大上传文件大小，默认2097152byte；自带的拦截器可以设置

image/bmp,image/x-png,image/gif,image/jpeg

20480

第20章 hibernate入门

20.1hibernate简介

Hibernate是一种对象-关系数据库-映射（ORM，object-relative database-mapping），将pojo拆分成各种属性自动组织sql语句，保存到数据库；或者将数据中数据抽取出来，拼装成pojo对象返回；

20.2使用hibernate步骤

新建webproject------右键addhibernateCapabilities------添加hibernate包------配置实体类----在hibernate.cfg.xml中配置数据库连接信息，还有注解实体类信息或者无注解的实体类+类配置文件信息；-----创建CatTest.java文件，severlet的main函数中创建Session相当于数据库连接------创建Transaction相当于任务-------然后用Session的函数去实现对象与数据库记录之间的映射；

可以将Hibernate的的数据库操作封装成一个类，将Session和transaction的创建和销毁封装起来；创建BaseDAO.java文件内部参数采用object，可以接收任意的实体类，hibernate实现实体类和数据库之间的数据交互；在severlet的doPost函数中根据不同的参数来调用不同的函数，函数中调用BaseDAO中封装的数据库操作函数；

package com.helloweenvsfei.hibernate.bean;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;

import javax.persistence.NamedQueries;

import javax.persistence.NamedQuery;

import javax.persistence.OneToMany;

import javax.persistence.QueryHint;

import javax.persistence.Table;

import javax.persistence.Temporal;

import javax.persistence.TemporalType;

//@NamedQuery(name = "all cat", query = " select c from Cat c ")

//@NamedNativeQuery(name = "all cat", query = "select * from tb_cat")

@NamedQueries(value = {

@NamedQuery(name = "all cat", query = " select c from Cat c "),

@NamedQuery(name = "cat by name", query = " select c from Cat c where c.name = :name ", hints = { @QueryHint(name = "org.hibernate.callable", value = "true") }),

@NamedQuery(name = "cat by mother", query = " select c from Cat c ") })

//@NamedNativeQueries(value = {

// @NamedNativeQuery(name = "all cat", query = "select * from tb_cat"),

// @NamedNativeQuery(name = "all cat", query = "select * from tb_cat"),

// @NamedNativeQuery(name = "all cat", query = "select * from tb_cat") })

@Entity

// 注解Entity表示该类能被Hibernate持久化

@Table(name = "tb_cat")

// 指定该Entity对应的数据表名

public class Cat {

@Id

@Column(name = "id")

// 指定该列为主键

@GeneratedValue(strategy = GenerationType.AUTO)

// 主键类型, auto为数据库自增长类型

private Integer id;

@Column(name = "name")

// 指定属性对应的数据库表的列为“name”

private String name;

@Column(name = "description")

// 同上。@Column与name均可省略

private String description;

@ManyToOne

// 指定POJO之间的关系，本例为多对一关系

@JoinColumn(name = "mother_id")

// 该属性对应的列

private Cat mother;

@Temporal(TemporalType.TIMESTAMP)

// 日期类型（DATE, TIME还是TIMESTEMP）

@Column(name = "createDate")

private Date createDate;

@OneToMany(mappedBy = "cat")

// @JoinColumns(value = { @JoinColumn(name = "cat_id", referencedColumnName

// = "id") })

private List events = new ArrayList();

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 Cat getMother() {

return mother;

}

public void setMother(Cat mother) {

this.mother = mother;

}

public Date getCreateDate() {

return createDate;

}

public void setCreateDate(Date createDate) {

this.createDate = createDate;

}

public String getDescription() {

return description;

}

public void setDescription(String description) {

this.description = description;

}

public List getEvents() {

return events;

}

public void setEvents(List events) {

this.events = events;

}

}

Hibernate操作数据库

// 开启一个 Hibernate 对话

Session session = HibernateSessionFactory.getSessionFactory()

.openSession();

// 开启一个事务

Transaction trans = session.beginTransaction();

// 将三只猫的资料保存到数据库

session.persist(mother);

session.persist(kitty);

session.persist(mimmy);

// 查询数据中的所有的猫

@SuppressWarnings("all")

List catList = session.createQuery(" from Cat ").list();

StringBuffer result = new StringBuffer();

result.append("数据库里的所有的猫：\r\n\r\n");

// 遍历 输出猫与猫妈妈

for (Cat cc : catList) {

result.append("猫: " + cc.getName() + ", ");

result.append("猫妈妈: "

+ (cc.getMother() == null ? "没有记录" : cc.getMother()

.getName()));

result.append("\r\n");

}

trans.commit();//结束事物

session.close();//关闭Session

第21章 从宏观上把握hibernate

SessionFactory是一个线程安全的Session工厂类，为不同的线程提供Session，维护这Session的相关德尔资源，包括数据库连接池等、缓存信息；

Transaction代表一次事物，事物提交后，修改的数据操作才会生效。

在hibernate.properties中配置数据库的类型和连接信息，在hibernate.cfg.xml中配置注解实体类或者实体类的配置文件；

第22章hibernate实体映射

主键配置（用@id申明主键，用@cloumn申明该列的名称，@GeneratedValue指定生成策略，可以是自增长、源于其他表格、sequence等）；主键生成规则（GenerationType.AUTO、GenerationType.TABLE、GenerationType.SEQUENCE、 GenerationType.INDENTITY）、

普通属性配置，使用@Cloumn配置，属性nullable（是否允许为null）、unique（是否唯一）、insertable（是否允许插入）updateable（是否允许更新）、length（列长度）、cloumnDefinition（列类型）、scale（整数长度）、precision（小数点精度）；

@Cloumn（name=“salry”，nullable=true，cloumnDefinition=“number”，insertable=true）

用@Basic为普通属性配置加载方式，默认及时加载，如果数据比较大，可设置为延时加载,optional配置该列是否可以为null；

@Basic（fetch=FetchType.LAZY,optional=true）// FetchType.EAGER

配置日期属性配置；如果日期类型是java.util.Date类型，必须用@temporal配置日期类型。如果是java.sql.Date、 java.sql. Time、java.sql.TimeStamp，则无需申明；

@Temporal（TemporalType.TIMESTAMP）

@Cloumn(name=”createDate”)

Private java.util.Date createDate;

临时属性；@Transient标注，表示临时为了方便计算而创建的属性，不会写入数据库；对应的getset方法也要配置；而对于所有没有配置到配置文件中都是临时属性；

版本属性；乐观锁和悲观锁@Version；悲观锁操作时锁住，完成后释放；乐观锁采用Version属性来判断是否被修改，是否要重新读取；允许多条线程同时访问数据；

@version

Private int version；//注解配置

//要配置在主键后，普通属性前

//配置文件配置可以是int、long、Timestamp；

第24章 Hibernate查询语言HQL

HQL是面向对象的语言，直接将对象用于数据库查询语句，大小写不敏感，同名时用package区分；

查询数量计数

Number num=（Number）Session.createQuery(“select count(c) from Cat c”).uniqueResult();

返回集合属性

List namelist =session.createQuery(“select c.name,c.mother.name from Cat c”).list();

List catlist=session.createQuery(select c.mother from Cat c).list();

返回不同的多个对象,对象数组

List olist=session.createQuery(“select c.name,c.mother ,c.createDate from Cat c”).list();

返回list类型

List list2=session.createQuery(“Select new list（c.name,c.mother,c.createDate）from Cat c”).list();

返回map类型

List listmap=Session.createQuery(“select new map(c.name as name,c.mother as mother, c.createDate as createDate ) from Cat c)”).list();

返回java实体对象

List catlist=session.createQuery(“select new Cat(cat.name,cat.createDate) from Cat c”).list();

条件语句

Session.createQuery(“select c from Cat c where c.mother=null and c.createDate <:createDate”).setParameter(“createDate”,new Date()).list();

统计函数

语句中Count（）、sum（）min（）、max()，avg（）、count（）；返回 uniqueResault（）类型与主键类型相同；

分页查询数据，获取查到的数据

List cslist =session.createQuery(“from Cat”).setFirstResult(0).setMaxResault(10).list();

跨表查询

Select e From event e where e.cat.name=’ketty’ 查询Event和cat表；

级联查询

List blist=session.createQuery(“Select c from Cat c left join c.events e where e.description like :description”).setParameter(“description”,”%吃早饭%”).List();

SQL查询

Session.createSQLQuery(“select * from tb_cat”);

@配置命名查询

将常用的查询用一个字符串来代替，相当于宏定义,在实体类的定义的前面配置

@NameQuery（name=”all cat”,query=”select c from Cat c”）//配置HQL查询

@NameNativeQuery（name=“all cat”，query=“select * from tb_cat”）

在xml配置文件中配置命名查询,name配置查询的名称，配置返回数据类型；

；

第26章 Spring概述

26.1Spring 框架

Spring是一种轻量级的框架或容器，一般的程序是从外到内的过程，即程序应用层（main函数实例化服务对象，调用服务的接口函数）、service层（实现服务接口函数，实例化DAO对象，并调用其方法）、DAO层（实现真正的业务逻辑）；而Spring则是从内到外的一个过程；

Spring使用流程，定义IDao的接口和实现类DaoImpl，定义IService接口和ServiceImpl实现类，在ServiceImpl定义IDao变量和set、get方法；而不是调用DAOimpl对象；通过配置文件将serviceImpl与DaoImpl类关联起来，建立依赖关系,相当于service.setDao(DaoImpl);Spring在运行时，根据配置注入依赖的对象，Spring实例化对象并维护对象，在编码阶段没有实例化，而是在运行阶段注入对象，并实例化、组装对象、维护对象，与传统的写代码，实例化、组装对象，执行方法方向相反；

class="com.helloweenvsfei.spring.example.ServiceImpl">

或者按照下面的配置

class="com.helloweenvsfei.spring.example.ServiceImpl">

26.3面向切面的编程

面向切面编程（Aspect oriented programming）将程序分成独立的几段，可以按不同顺序执行，方便添加删除功能；Spring实现了特定的AOP即可的类称为拦截器；

package com.helloweenvsfei.spring.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class MethodBeforeInterceptor implements MethodBeforeAdvice {

public void before(Method method, Object[] args, Object instance)方法、参数、实例；

throws Throwable {

System.out.println("即将要执行方法：" + method.getName());

if (instance instanceof AopServiceImpl) {

String name = ((AopServiceImpl) instance).getName();

if (name == null)

throw new NullPointerException("name属性不能为null");

}

}

}

第27章 Spring的core模块

Core的主要功能是实现反向控制、依赖注入、beans配置和加载；有Beans、BeanFactory（加载beans）、BeanDefinition（beans的定义）ApplicationContext（配置文件）；

27.1BeanFactory工厂

BeanFactory根据配置实例化beans对象，并设置相互依赖性，将beans注入sevelet、struts的Action中、Hibernate资源中；web程序无需实例化BeanFactory，自动实例化；java桌面程序中需要根据配置文件加载实例化，用ClassPathResourse加载ClassPath下的文件，或者用FileInputStream加载任意路径的配置文件，或者用ClassPathXmlApplicationContext加载多个配置文件；

27.2 配置java bean

配置文件中用id配置名称，class配置类名，必须两个参数；如果为工厂类（无类名构造函数），需要用factory-bean配置类名，factory-method配置构造函数名称；如果构造函数有参数，需要用配置参数；

单态模式singleton，默认为单态模式，非单态模式需要设置bean属性singleton=“false”；

属性设置，通过配置，Spring根据set方法设置；

class="org.apache.commons.dbcp.BasicDataSource"

//配置构造函数的两个参数，一个bean参数，一个数值参数， ref表示引用配置文件中其他的bean；yetBean为id

1

destroy-method="close" （关闭方法，析构函数）singleton=”true”>//单态模式

//配置属性

value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" />

配置list、set、map属性

//list属性配置

aopMethodBeforeInterceptor

aopMethodAfterInterceptor

aopThrowsInterceptor

//set属性配置

aopMethodBeforeInterceptor

//map键值对的键

just some string//map键值对的值

//bean map

depend-on设置依赖关系，加载之前先加载依赖的对象；

class="com.helloweenvsfei.spring.dao.PersonDaoImpl"

depends-on="dataSource" init-method="initDatabase">//依赖关系和初始化方法

27.3属性自动装填autowire

设置bean为自动装填后，会根据设置的规则去自动设置，不用设置；

27.4依赖检查dependency

检查bean的属性是否被设置，还可以设置为no、simple、object、all；

，

27.5Bean的高级特性

继承Spring的一些接口BeanNameAware和BeanFactoryAware，设置或获取bean的id、BeanFactory和初始化和销毁函数，但是会使程序与Spring耦合，依赖Spring的类库；

27.6BeanFactory高级特性

如果实现了BeanFactoryAware接口，可以获取BeanFactory对象，可以调用他的方法判断是否包含Bean，获取指定名称的bean，是否配置为singleton等；

第28章 Spring的AOP模块

28.1拦截器的使用

AOP是面向切面的编程方法，将一个业务流程分成几部分实现，再组装成一个完整的流程；

先定义IAopServiceAop.java接口，定义两个函数withaop和withoutaop；创建IAopServiceAopImpl.java实现类，实现两个方法；创建文件*interceptor.java实现MethodBeforeAdvice、AfterReturningAdvice、ThrowsAdvice接口，实现三种拦截器；在配置文件ApplicationContext.xml中配置三种拦截器和拦截的方法，配置service对象，并采用list配置三种拦截器；在main函数中执行方法；

Spring无法将service实现类和拦截器直接组装，需要把拦截器安装到代理类NameMatchMethodPointcutAdvisor，把自定义的Service安装到ProxyFactoryBean中，

class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

class="com.helloweenvsfei.spring.aop.MethodBeforeInterceptor" />

class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

class="com.helloweenvsfei.spring.aop.MethodAfterInterceptor" />

class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

class="com.helloweenvsfei.spring.aop.ThrowsInterceptor" />

class="org.springframework.aop.framework.ProxyFactoryBean">

//用list配置三种拦截器

aopMethodBeforeInterceptor

aopMethodAfterInterceptor

aopThrowsInterceptor

class="com.helloweenvsfei.spring.aop.AopServiceImpl">

在main函数中执行函数

package com.helloweenvsfei.spring.aop;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.ClassPathResource;

public class AopRun {

public static void main(String[] args) throws Exception {

XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource(

"applicationContext.xml"));

IAopService hello = (IAopService) factory.getBean("aopService");

hello.withAop();

hello.withoutAop();

factory.destroySingletons();

}

}

28.2拦截器和Filter区别

两者都是基于AOP的编程思想；在程序应用范围、使用容器、使用资源、使用深度上有所区别；Filter只能用于web程序，拦截器还可以用于Application和swing；filter适用Servlet容器，拦截器适用于Spring容器；拦截器可以使用的资源更多；filter只能在servlet前后使用，Spring更深入，能在方法前后使用；

第29章 Spring的DAO模块

29.1数据库操作封装

Spring对jdbc进行了封装，不需要进行数据库连接和事物提交等工作；直接用jdbcTemplate执行SQL语句；

实现步骤 定义Person.java文件实现Person类，定义属性和set、get方法；创建IPersonDao.java文件，定义操作接口；创建PersonDaoImpl.java文件，实现IPersonDao接口并继承与JdbcDaoSupport类，实现接口函数是对象与数据库的映射关系，并定义初始化initDateBase（）函数用于创建数据库表格，JdbcDaoSupport类封装了数据库连接和任务，通过jdbcTemplate执行sql语句，getJdbcTemplate（）获取对象，调用方法queryForList（sql），update（sql，new object[]{}）；在ApplicationContext.xml配置文件中配置数据源，即数据库的类型、名称、url、登陆用户名和密码等信息；在配置文件的DAO中配置数据源和初始化函数；运行程序，创建DaoRun.java文件，在main函数中创建BeanFactory对象，加载

29.2实体对象与数据库映射

继承MappingSqlQurry抽象类，实现mapRow接口，接口内将查询结果赋值给对象，需要调用setDateSource()、setsql（）函数设置数据源和sql语句，调用compile（）执行编译，调用declareParameter（）设置参数，调用execute（）返回结果；

ApplicationContext.xml文件，获取IPersonDao对象，调用对象的函数实现对象到数据库的操作；

package com.helloweenvsfei.spring.dao;

import java.sql.ResultSet;

import java.sql.SQLException;

import org.springframework.jdbc.object.MappingSqlQuery;

public class PersonMappingQuery extends MappingSqlQuery {

@Override

protected Object mapRow(ResultSet rs, int columnIndex) throws SQLException {

Person person = new Person();

person.setId(rs.getInt("id"));

person.setName(rs.getString("name"));

person.setSex(rs.getString("sex"));

person.setAge(rs.getInt("age"));

person.setBirthday(rs.getTimestamp("birthday"));

return person;

}

}

继承SqlUpdate类，执行SQL更新语句。继承SqlDunction返回单一结果；

29.3Spring的事物管理

Spring默认在DAO的方法上加事物，一个方法算一个事物；但是一个方法执行失败不会让上一个方法回滚；

先配置一个事物管理者jdbcTransactionManager，传入数据源信息，在ApplicationContext.xml按照bean配置；为事物管理者配置事物属性transactionAttributeSource；为IPersonDao类配置管理者和管理属性；run方法中某个调用函数失败，整个run方法会回滚；

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">//事物管理者

class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">

PROPAGATION_REQUIRED

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

ref="jdbcTransactionManager" />

class="com.helloweenvsfei.spring.dao.TransactionRun">

ref="transactionAttributeSource" />

第30章 Spring的ORM模块

30.1Spring保存实体类

Spring封装了hibernate的Session和transation，内部管理这些资源；让用户只需关心对象与数据库之间的关系映射（Object-Relational Mapping）；

使用步骤

创建Cat.java文件，定义Cat实体类，加注解；创建ICatDao.java文件定义ICatDao接口；创建CatDaoImpl.java文件实现ICatDao接口并继承HibernateDaoSupport类，该类提供HibernateTemplate对象对实体类进行操作；

package com.helloweenvsfei.spring.orm;

import java.util.List;

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

public class CatDaoImpl extends HibernateDaoSupport implements ICatDao {

public void createCat(Cat cat) {

this.getHibernateTemplate().persist(cat);

}

public Cat findCatByName(String name) {

List catList = this.getHibernateTemplate().find(

" select c from Cat c where c.name = ? ", name);

if (catList.size() > 0)

return catList.get(0);

return null;

}

public int getCatsCount() {

return (Integer) this.getSession(true).createQuery(

" select count(c) from Cat c ").uniqueResult();

}

public List listCats() {

return this.getHibernateTemplate().find(" select c from Cat c ");

}

}

30.2Spring中配置Hibernate

需要在ApplicationContext.xml中配置数据源、SessionFactory及CatDaoImpl、实体类；先配置数据源，然后配置SessionFactory，在SessionFactory中配置数据源，和加载的实体类路径和实体类名称，最后配置实体类操作类DAOImpl，设置SessionFactory属性；也可以加载配置文件配置的实体类；

class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

value="jdbc:mysql://localhost:3306/spring?characterEncoding=UTF-8" />

配置SessionFactory

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"

destroy-method="destroy">

value="classpath:/com/helloweenvsfei/spring/orm">

配置实体类

com.helloweenvsfei.spring.orm.Cat

配置Hibernate属性

org.hibernate.dialect.MySQLDialect

true

false

create

class="com.helloweenvsfei.spring.orm.CatDaoImpl">

设置SessionFactory

30.3管理Hibernate事物

Spring默认在DAO层添加事物，每个方法一个事物。在DAO层添加service，在service层添加事物；

先定义一个HibernateTransactionManager管理器，在管理器中添加SessionFactory；然后添加事物管理规则，为所有的方法添加事物；借助Spring的代理类TransactionProxyFactoryBean，为DAOimpl配置事物管理器和管理规则

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

配置SessionFactory

class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">//使用代理类

PROPAGATION_REQUIRED//所有方法加上事物

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

ref="hibernateTransactionManager">

class="com.helloweenvsfei.spring.orm.CatServiceImpl"> CatServiceImpl不能直接加事物，需要借助TransactionProxyFactoryBean代理类

//设置DAO依赖关系catDao是.CatServiceImpl的一个属性

ref="hibernateTransactionAttributeSource">

第31章 Spring的web模块

31.1整合strut1.x:继承方式

CatAction直接继承ActionSupport类，GetWebApplicationContext().getBean(“iCatService”)先获取beanFactory，然后再获取各种资源；在CatAction中添加execute方法，作为action的主方法，根据action的动作执行方法；然后在struts配置文件中配置action对应的文件名称。

Spring和struts需要配置到web.xml文件中，Spring要配置ApplicationContext.xml的位置，以及加载配置文件的ContextLoadLisener

自己编了一个股票监控软件，有如下功能，有兴趣的朋友可以下载；

（1） 个股监测。监测个股实时变化，可以监测个股大单交易、急速拉升和下降、主力入场和出场、股票最高点和最低点提醒。检测到最高点、最低点、主力进场点、主力退场点、急速拉升点、急速下跌点，给出语音或者声音提醒，不用再时刻看着大盘了，给你更多自由的时间；

（2） 大盘监测。监测大盘的走势，采用上证、深证、创业三大指数的综合指数作为大盘走势。并实时监测大盘的最高点和最低点、中间的转折点。

（3） 股票推荐。还能根据历史数据长期或短期走势进行分析，对股市3千多个股票进行分析对比，选出涨势良好的股票，按照增长速度从大到小排序，推荐给你涨势良好的股票；

下载地址：

1.0.3版本（修复大盘指数崩溃缺陷）下载地址：

链接：https://pan.baidu.com/s/1BJcTp-kdniM7VE9K5Kd3vg 提取码：003h

更新链接：

https://www.cnblogs.com/bclshuai/p/10621613.html