Spring基础

来源：互联网发布：怪物猎人3g数据库下载编辑：程序博客网时间：2024/06/06 15:40

Spring EJB太复杂轻量级的框架 JavaBean代理EJB 控制反转IOC解耦面向切面AOP

Spring jar包 commons-collections-3.2 commons-logging spring-aop-4.0.6.RELEASE spring-beans-4.0.6.RELEASE spring-context-4.0.6.RELEASE spring-core-4.0.6.RELEASE spring-expression-4.0.6.RELEASE

Spring可以单例形式管理实例Bean

beans.xml

package com.java1234.service;

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

import com.java1234.test.HelloWorld;

public class Test {

public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml"); 接口加载配置文件
HelloWorld helloWorld=(HelloWorld)ac.getBean("helloWorld"); 通过id获取bean
helloWorld.say(); 通过spring管理的对象调用方法
}
}

IOC 控制翻转又称为依赖注入解耦

package com.java1234.service;

public class ZhangSan implements Tester{

public void test(){
System.out.println("张三-测试程序");
}
}

package com.java1234.service;

public class JavaWork {

private Tester tester;

public void setTester(Tester tester) {
this.tester = tester;
}

public void doTest(){
/*ZhangSan zhangsan=new ZhangSan();
zhangsan.test();*/ 有个人做测试工作人耦合在一起换人要lisi也做测试
tester.test();
}
}

package com.java1234.test;

import com.java1234.service.JavaWork;
import com.java1234.service.Lisi;

public class Test {

/**
* 主管执行命令
* @param args
*/
public static void main(String[] args) {
JavaWork javaWork=new JavaWork();
// javaWork.setTester(new ZhangSan()); 有一个人去执行命令
javaWork.setTester(new Lisi());
javaWork.doTest();
}
}

-----------------

package com.java1234.service;

public interface Tester { 接口方法

public void test();
}

package com.java1234.service;

public class ZhangSan implements Tester{ 通过多态实现方法

public void test(){
System.out.println("张三-测试程序");
}
}

package com.java1234.service;

public class Lisi implements Tester{

public void test(){
System.out.println("李四-测试程序");
}
}

package com.java1234.service;

public class JavaWork {

private Tester tester;

public void setTester(Tester tester) {
this.tester = tester;
}

public void doTest(){
/*ZhangSan zhangsan=new ZhangSan();
zhangsan.test();*/
tester.test(); 具体谁执行主管的人决定不管具体的人
}
}

package com.java1234.test;

import com.java1234.service.JavaWork;
import com.java1234.service.Lisi;

public class Test {

/**
* 主管执行命令
* @param args
*/
public static void main(String[] args) {
JavaWork javaWork=new JavaWork();
// javaWork.setTester(new ZhangSan());
javaWork.setTester(new Lisi()); 具体new一个人来组测试
javaWork.doTest();
}
}

spring管理ioc容器

package com.java1234.test;

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

import com.java1234.service.JavaWork;

public class Test2 {

public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
JavaWork javaWork=(JavaWork)ac.getBean("javaWork"); id
javaWork.doTest(); 换的时候该ref=“lisi” 把设置具体设置属性交给spring的bean管理依赖注入底层通过java反射机制找到的
}
}

依赖注入方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="people" class="com.java1234.entity.People"></bean> spring来管理bean id唯一标识通过id 取实例

<bean id="people2" class="com.java1234.entity.People">
<property name="id" value="1"></property> name是属性注入了属性通过set方法
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
</bean>

<bean id="people3" class="com.java1234.entity.People"> 构造方法注入
<constructor-arg type="int" value="2"></constructor-arg>
<constructor-arg type="String" value="李四"></constructor-arg>
<constructor-arg type="int" value="22"></constructor-arg>
</bean>

<bean id="people4" class="com.java1234.entity.People"> 通过索引顺序
<constructor-arg index="0" value="3"></constructor-arg>
<constructor-arg index="1" value="王五"></constructor-arg>
<constructor-arg index="2" value="55"></constructor-arg>
</bean>

<bean id="people5" class="com.java1234.entity.People"> 联合使用
<constructor-arg index="0" type="int" value="4"></constructor-arg>
<constructor-arg index="1" type="String" value="招六"></constructor-arg>
<constructor-arg index="2" type="int" value="66"></constructor-arg>
</bean>

<bean id="peopleFactory" class="com.java1234.factory.PeopleFactory"></bean> 工厂方法注入非静态工厂要定义bean

<bean id="people7" factory-bean="peopleFactory" factory-method="createPeople"></bean> 引入factory-bean那个工厂的工厂的哪个方法

<bean id="people8" class="com.java1234.factory.PeopleFactory2" factory-method="createPeople"></bean> 静态调用不需要new 直接类调用方法
</beans>

package com.java1234.test;

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

import com.java1234.entity.People;

public class Test2 {

public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
People people=(People)ac.getBean("people");
System.out.println(people); 调用默认的构造方法

// 属性注入
People people2=(People)ac.getBean("people2");
System.out.println(people2);

// 构造方法注入

public People(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}

People people3=(People)ac.getBean("people3");
System.out.println(people3);

People people4=(People)ac.getBean("people4");
System.out.println(people4);

People people5=(People)ac.getBean("people5");
System.out.println(people5);

// 工厂方法注入
People people7=(People)ac.getBean("people7");
System.out.println(people7);

People people8=(People)ac.getBean("people8");
System.out.println(people8);
}
}

非静态工厂工厂注入

package com.java1234.factory;

import com.java1234.entity.People;

public class PeopleFactory {

public People createPeople(){ 方法不是静态的工厂需要new
People p=new People(); 返回之后是people new一个people
p.setId(5);
p.setName("小七");
p.setAge(77);
return p;
}
}

静态工厂

package com.java1234.factory;

import com.java1234.entity.People;

public class PeopleFactory2 {

public static People createPeople(){
People p=new People();
p.setId(8);
p.setName("小八");
p.setAge(88);
return p;
}
}

注入参数

public class People {

private int id;
private String name;
private int age;
private Dog dog; 作为people的属性
private List<String> hobbies=new ArrayList<String>();
private Set<String> loves=new HashSet<String>();
private Map<String,String> works=new HashMap<String,String>();
private Properties addresses=new Properties();

package com.java1234.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.java1234.entity.People;

public class T {

private ApplicationContext ac; 声明

@Before
public void setUp() throws Exception {
ac=new ClassPathXmlApplicationContext("beans.xml");
}

// 基本类型值
@Test
public void test1() {
People people=(People)ac.getBean("people1");
System.out.println(people);
}

// 注入bean
@Test
public void test2() {
People people=(People)ac.getBean("people2");
System.out.println(people);
}

// 内部bean
@Test
public void test3() {
People people=(People)ac.getBean("people3");
System.out.println(people);
}

// 注入null
@Test
public void test4() {
People people=(People)ac.getBean("people4");
System.out.println(people);
}

// 级联属性
@Test
public void test5() {
People people=(People)ac.getBean("people5");
System.out.println(people);
}

// 注入集合
@Test
public void test6() {
People people=(People)ac.getBean("people6");
System.out.println(people);
}
}

<bean id="people2" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
<property name="dog" ref="dog1"></property> 引用注入 bean之间的嵌套
</bean>

<bean id="people3" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
<property name="dog"> 只能被一个引用

<bean class="com.java1234.entity.Dog"> 内部bean
<property name="name" value="Tom"></property>
</bean>
</property>
</bean>

<bean id="people4" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
<property name="dog">
<null></null> 注入null
</property>
</bean>

注入集合

<bean id="people6" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
<property name="dog" ref="dog1"></property>
<property name="hobbies">
<list>
<value>唱歌</value>
<value>跳舞</value>
</list>
</property>
<property name="loves">
<set>
<value>唱歌2</value>
<value>跳舞2</value>
</set>
</property>
<property name="works">
<map>
<entry>
<key><value>上午</value></key>
<value>写代码</value>
</entry>
<entry>
<key><value>下午</value></key>
<value>测试代码</value>
</entry>
</map>
</property>
<property name="addresses">
<props>
<prop key="address1">aaaaa</prop>
<prop key="address2">bbbbb</prop>
</props>
</property>
</bean>

自动装配

public People(Dog dog) {
super();
System.out.println("constructor");
this.dog = dog;
}

<bean id="dog2" class="com.java1234.entity.Dog">
<property name="name" value="Jack"></property>
</bean>

<bean id="people1" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property> 以前要手动注入dog

</bean>

</beans>

方法注入

每次获取狗都获取新的狗

public abstract class People { 抽象具体实现让spring实现

public abstract Dog getDog();

bean之间的关系

public class People {

private int id;
private String name;
private int age;
private String className;
private Dog dog;

@Test
public void test1() {
People zhangsan=(People)ac.getBean("zhangsan"); People类 Bean的id
System.out.println(zhangsan);

People lisi=(People)ac.getBean("lisi");
System.out.println(lisi);
}

权限

public class Authority {

public Authority() {
System.out.println("获取权限");
}

}

bean作用范围

1，singleton Spring ioc 容器中仅有一个 Bean 实例，Bean 以单例的方式存在；true同一个

2，prototype 每次从容器中调用 Bean 时，都返回一个新的实例；

3，request 每次 HTTP 请求都会创建一个新的 Bean；

4，session 同一个 HTTP Session 共享一个 Bean；5，global session 同一个全局 Session 共享一个 Bean，一般用于 Portlet 应用环境；6，application 同一个 Application 共享一个 Bean；

、

AOP

面向切面

对业务逻辑切入新的功能

package com.java1234.service;

public interface StudentService {

public void addStudent(String name);
}

package com.java1234.service.impl;

import com.java1234.service.StudentService;

public class StudentServiceImpl implements StudentService{

@Override
public void addStudent(String name) {
// System.out.println("开始添加学生"+name); 对原有代码的侵入同类的代码都要封装起来
System.out.println("添加学生"+name);
// System.out.println("完成学生"+name+"的添加");
}

}

切面

package com.java1234.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class StudentServiceAspect {

public void doBefore(JoinPoint jp){ 前置通知
System.out.println("类名:"+jp.getTarget().getClass().getName()); 获取类名
System.out.println("方法名："+jp.getSignature().getName());
System.out.println("开始添加学生："+jp.getArgs()[0]);
}

public void doAfter(JoinPoint jp){
System.out.println("类名:"+jp.getTarget().getClass().getName());
System.out.println("方法名："+jp.getSignature().getName());
System.out.println("学生添加完成："+jp.getArgs()[0]);
}

public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("添加学生前");
Object retVal=pjp.proceed();
System.out.println(retVal);
System.out.println("添加学生后");
return retVal;
}

public void doAfterReturning(JoinPoint jp){
System.out.println("返回通知");
}

public void doAfterThrowing(JoinPoint jp,Throwable ex){
System.out.println("异常通知");
System.out.println("异常信息："+ex.getMessage());
}
}

spring对jdbc支持

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_spring
jdbc.username=root
jdbc.password=123456

package com.java1234.dao;

import java.util.List;

import com.java1234.model.Student;

public interface StudentDao {

public int addStudent(Student student);

public int updateStudent(Student student);

public int deleteStudent(int id);

public List<Student> findStudents();
}

CRUD操作

package com.java1234.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;

import com.java1234.dao.StudentDao;
import com.java1234.model.Student;

public class StudentDaoImpl implements StudentDao{

private JdbcTemplate jdbcTemplate; 引入模板 set方法把jdbc从配置文件注入

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}

@Override
public int addStudent(Student student) {
String sql="insert into t_student values(null,?,?)"; 主键自增
Object []params=new Object[]{student.getName(),student.getAge()}; 传入对象数组
return jdbcTemplate.update(sql,params);
}

@Override
public int updateStudent(Student student) {
String sql="update t_student set name=?,age=? where id=?";
Object []params=new Object[]{student.getName(),student.getAge(),student.getId()};
return jdbcTemplate.update(sql,params);
}

@Override
public int deleteStudent(int id) {
String sql="delete from t_student where id=?";
Object []params=new Object[]{id};
return jdbcTemplate.update(sql,params);
}

@Override
public List<Student> findStudents() {
String sql="select * from t_student";
final List<Student> studentList=new ArrayList<Student>();
jdbcTemplate.query(sql, new RowCallbackHandler(){

@Override
public void processRow(ResultSet rs) throws SQLException {
Student student=new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
studentList.add(student);
}

});
return studentList;
}

}

package com.java1234.service.impl;

import java.util.List;

import com.java1234.dao.StudentDao;
import com.java1234.model.Student;
import com.java1234.service.StudentService;

public class StudentServiceImpl implements StudentService{

private StudentDao studentDao; set注入

public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}

@Override
public int addStudent(Student student) {
return studentDao.addStudent(student);
}

@Override
public int updateStudent(Student student) {
return studentDao.updateStudent(student);
}

@Override
public int deleteStudent(int id) {
return studentDao.deleteStudent(id);
}

@Override
public List<Student> findStudents() {
return studentDao.findStudents();
}

}

package com.java1234.test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.java1234.model.Student;
import com.java1234.service.StudentService;

public class T {

private ApplicationContext ac;

@Before
public void setUp() throws Exception {
ac=new ClassPathXmlApplicationContext("beans.xml");
}

@Test
public void addStudent() {
StudentService studentService=(StudentService)ac.getBean("studentService");获取service
int addNums=studentService.addStudent(new Student("王五", 1)); 添加对象进去需要构造方法
if(addNums==1){
System.out.println("添加成功");
}
}

@Test
public void updateStudent() {
StudentService studentService=(StudentService)ac.getBean("studentService");
int updateNums=studentService.updateStudent(new Student(8,"王五2", 2));
if(updateNums==1){
System.out.println("更新成功");
}
}

@Test
public void deleteStudent() {
StudentService studentService=(StudentService)ac.getBean("studentService");
int deleteNums=studentService.deleteStudent(8);
if(deleteNums==1){
System.out.println("删除成功");
}
}

@Test
public void findStudents() {
StudentService studentService=(StudentService)ac.getBean("studentService");
List<Student> studentList=studentService.findStudents();
for(Student student:studentList){
System.out.println(student);
}
}
}

JDBC对hibernate支持

ublic class StudentDaoImpl extends JdbcDaoSupport implements StudentDao{ 不需要private JDBCtemplate

return this.getJdbcTemplate().update(sql,params);

package com.java1234.dao.impl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

import com.java1234.dao.StudentDao;
import com.java1234.model.Student;

public class StudentDaoImpl implements StudentDao{

private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

public void setNamedParameterJdbcTemplate(
NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
}

@Override
public int addStudent(Student student) {
String sql="insert into t_student values(null,:name,:age)"; 命名不用？
MapSqlParameterSource sps=new MapSqlParameterSource();
sps.addValue("name", student.getName());
sps.addValue("age", student.getAge());
return namedParameterJdbcTemplate.update(sql,sps);
}

@Override
public int updateStudent(Student student) {
String sql="update t_student set name=:name,age=:age where id=:id";
MapSqlParameterSource sps=new MapSqlParameterSource();
sps.addValue("name", student.getName());
sps.addValue("age", student.getAge());
sps.addValue("id", student.getId());
return namedParameterJdbcTemplate.update(sql,sps);
}

@Override
public int deleteStudent(int id) {
String sql="delete from t_student where id=:id";
MapSqlParameterSource sps=new MapSqlParameterSource();
sps.addValue("id", id);
return namedParameterJdbcTemplate.update(sql,sps);
}

@Override
public List<Student> findStudents() {
String sql="select * from t_student";
final List<Student> studentList=new ArrayList<Student>();
namedParameterJdbcTemplate.query(sql, new RowCallbackHandler(){

@Override
public void processRow(ResultSet rs) throws SQLException {
Student student=new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
studentList.add(student);
}

});
return studentList;
}

}

JDBC对事物支持原子性一致性隔离线持久性

public interface BankService { 事物层随时更改实现，每个方法可以有多个dao操作

/**
* A向B转账count元
* @param count
* @param userIdA
* @param userIdB
*/
public void transferAccounts(int count,int userIdA,int userIdB);
}

package com.java1234.service.impl;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import com.java1234.dao.BankDao;
import com.java1234.service.BankService;

public class BankServiceImpl implements BankService{

private BankDao bankDao; 引入dao

private TransactionTemplate transactionTemplate; 注入事物

public void setBankDao(BankDao bankDao) {
this.bankDao = bankDao;
}

public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
this.transactionTemplate = transactionTemplate;
}

@Override
public void transferAccounts(final int count, final int userIdA, final int userIdB) { 内部类要final
// TODO Auto-generated method stub
transactionTemplate.execute(new TransactionCallbackWithoutResult() { 接口内部类

@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
// TODO Auto-generated method stub
bankDao.outMoney(count, userIdA);
bankDao.inMoney(count, userIdB);
}
});
}

}

public class T {

private ApplicationContext ac;

@Before
public void setUp() throws Exception {
ac=new ClassPathXmlApplicationContext("beans.xml");
}

@Test
public void transferAccounts() {
BankService bankService=(BankService)ac.getBean("bankService"); 获取service的bean id
bankService.transferAccounts(50, 1, 2); 从1到2转50
}
}

上面事物已经入侵业务逻辑

<?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/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.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">

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>


<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>


<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="insert*" propagation="REQUIRED" /> 切的都是切方法
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="edit*" propagation="REQUIRED" />
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="new*" propagation="REQUIRED" />
<tx:method name="set*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="change*" propagation="REQUIRED" />
<tx:method name="get*" propagation="REQUIRED" read-only="true" />
<tx:method name="find*" propagation="REQUIRED" read-only="true" />
<tx:method name="load*" propagation="REQUIRED" read-only="true" />
<tx:method name="*" propagation="REQUIRED" read-only="true" />
</tx:attributes>
</tx:advice>

 xml方式配置这一块所有service都有效果否则每一个service都要有 @transac
<aop:config>

<aop:pointcut id="serviceMethod" expression="execution(* com.java1234.service.*.*(..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/> ref上面的id
</aop:config>


<context:property-placeholder location="jdbc.properties"/>

<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg ref="dataSource"></constructor-arg>
</bean>

<bean id="bankDao" class="com.java1234.dao.impl.BankDaoImpl">
<property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"></property>
</bean>

<bean id="bankService" class="com.java1234.service.impl.BankServiceImpl">
<property name="bankDao" ref="bankDao"></property>
</bean>

</beans>

注解方法

import org.springframework.transaction.annotation.Transactional;

import com.java1234.dao.BankDao;
import com.java1234.service.BankService;

@Transactional
public class BankServiceImpl implements BankService{

private BankDao bankDao;

public void setBankDao(BankDao bankDao) {
this.bankDao = bankDao;
}

@Override
public void transferAccounts(int count, int userIdA, int userIdB) {
// TODO Auto-generated method stub
// TODO Auto-generated method stub
bankDao.outMoney(count, userIdA);
bankDao.inMoney(count, userIdB);
}
}

事务传播行为

事务传播行为：Spring 中，当一个 service 方法调用另外一个 service 方法的时候，因为每个 service 方法都有事务，这时候就出现了事务的嵌套；由此，就产生了事务传播行为；在 Spring 中，通过配置 Propagation，来定义事务传播行为；

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

Spring整合hibernate 和struts2

web,xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>S2SH</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>


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


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

 session关闭页面取不到数据
<filter>
<filter-name>openSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
<init-param>
<param-name>singleSession</param-name>
<param-value>true</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>openSessionInViewFilter</filter-name>
<url-pattern>*.action</url-pattern> 所有的struts2请求
</filter-mapping>
</web-app>

<?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>
<constant name="struts.action.extension" value="action" /> 后缀是action
<package name="s2sh" namespace="/user" extends="struts-default">

<action name="user_*" method="{1}" class="com.java1234.action.UserAction"> name用通配符user_loging 自动调用login方法
<result name="success">/success.jsp</result>
<result name="error">/index.jsp</result>
</action>
</package>

</struts>

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>


<property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>


<property name="show_sql">true</property>


<property name="hbm2ddl.auto">update</property>


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

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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">


<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql://localhost:3306/test">
</property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
</bean>


<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
 hibernate实体类
<property name="packagesToScan"> 下面所有的类都会扫描
<list>
<value>com.java1234.entity</value>
</list>
</property>
</bean>


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


<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>
<tx:method name="insert*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="edit*" propagation="REQUIRED" />
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="new*" propagation="REQUIRED" />
<tx:method name="set*" propagation="REQUIRED" />
<tx:method name="remove*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="change*" propagation="REQUIRED" />
<tx:method name="get*" propagation="REQUIRED" read-only="true" />
<tx:method name="find*" propagation="REQUIRED" read-only="true" />
<tx:method name="load*" propagation="REQUIRED" read-only="true" />
<tx:method name="*" propagation="REQUIRED" read-only="true" />
</tx:attributes>
</tx:advice>



<aop:config>
<aop:pointcut id="serviceOperation"
expression="execution(* com.java1234.service..*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation" />
</aop:config>


<context:component-scan base-package="com.java1234" /> 后面配置的类都用注解不用手工配置

</beans>

package com.java1234.dao;

import java.io.Serializable;
import java.util.List;

/**
* 基础数据库操作类
*
* @author www.java1234.com
*
*/
public interface BaseDao<T> { spring4支持泛型注入

/**
* 保存一个对象
*
* @param o
* @return
*/
public Serializable save(T o); 常用操作封装起来

/**
* 删除一个对象
*
* @param o
*/
public void delete(T o);

/**
* 更新一个对象
*
* @param o
*/
public void update(T o);

/**
* 保存或更新对象
*
* @param o
*/
public void saveOrUpdate(T o);

/**
* 查询
*
* @param hql
* @return
*/
public List<T> find(String hql);

/**
* 查询集合
*
* @param hql
* @param param
* @return
*/
public List<T> find(String hql, Object[] param);

/**
* 查询集合
*
* @param hql
* @param param
* @return
*/
public List<T> find(String hql, List<Object> param);

/**
* 查询集合(带分页)
*
* @param hql
* @param param
* @param page
* 查询第几页
* @param rows
* 每页显示几条记录
* @return
*/
public List<T> find(String hql, Object[] param, Integer page, Integer rows);

/**
* 查询集合(带分页)
*
* @param hql
* @param param
* @param page
* @param rows
* @return
*/
public List<T> find(String hql, List<Object> param, Integer page, Integer rows);

/**
* 获得一个对象
*
* @param c
* 对象类型
* @param id
* @return Object
*/
public T get(Class<T> c, Serializable id);

/**
* 获得一个对象
*
* @param hql
* @param param
* @return Object
*/
public T get(String hql, Object[] param);

/**
* 获得一个对象
*
* @param hql
* @param param
* @return
*/
public T get(String hql, List<Object> param);

/**
* select count(*) from 类
*
* @param hql
* @return
*/
public Long count(String hql);

/**
* select count(*) from 类
*
* @param hql
* @param param
* @return
*/
public Long count(String hql, Object[] param);

/**
* select count(*) from 类
*
* @param hql
* @param param
* @return
*/
public Long count(String hql, List<Object> param);

/**
* 执行HQL语句
*
* @param hql
* @return 响应数目
*/
public Integer executeHql(String hql);

/**
* 执行HQL语句
*
* @param hql
* @param param
* @return 响应数目
*/
public Integer executeHql(String hql, Object[] param);

/**
* 执行HQL语句
*
* @param hql
* @param param
* @return
*/
public Integer executeHql(String hql, List<Object> param);

}

package com.java1234.dao.impl;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.java1234.dao.BaseDao;

@Repository("baseDao") 注解自动加载构建bean spring会扫描java1234包下所有的类把类变为bean id是BaseDao 可以注入到其他的地方
@SuppressWarnings("all")
public class BaseDaOImpl<T> implements BaseDao<T> { 有100个impl

private SessionFactory sessionFactory;

public SessionFactory getSessionFactory() {
return sessionFactory;
}

@Autowired 实在spring中配置的id 要写set方法注入
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

private Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}

public Serializable save(T o) {
return this.getCurrentSession().save(o);
}

public void delete(T o) {
this.getCurrentSession().delete(o);
}

public void update(T o) {
this.getCurrentSession().update(o);
}

public void saveOrUpdate(T o) {
this.getCurrentSession().saveOrUpdate(o);
}

public List<T> find(String hql) {
return this.getCurrentSession().createQuery(hql).list();
}

public List<T> find(String hql, Object[] param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.length > 0) {
for (int i = 0; i < param.length; i++) {
q.setParameter(i, param[i]);
}
}
return q.list();
}

public List<T> find(String hql, List<Object> param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.size() > 0) {
for (int i = 0; i < param.size(); i++) {
q.setParameter(i, param.get(i));
}
}
return q.list();
}

public List<T> find(String hql, Object[] param, Integer page, Integer rows) {
if (page == null || page < 1) {
page = 1;
}
if (rows == null || rows < 1) {
rows = 10;
}
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.length > 0) {
for (int i = 0; i < param.length; i++) {
q.setParameter(i, param[i]);
}
}
return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
}

public List<T> find(String hql, List<Object> param, Integer page, Integer rows) {
if (page == null || page < 1) {
page = 1;
}
if (rows == null || rows < 1) {
rows = 10;
}
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.size() > 0) {
for (int i = 0; i < param.size(); i++) {
q.setParameter(i, param.get(i));
}
}
return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
}

public T get(Class<T> c, Serializable id) {
return (T) this.getCurrentSession().get(c, id);
}

public T get(String hql, Object[] param) {
List<T> l = this.find(hql, param);
if (l != null && l.size() > 0) {
return l.get(0);
} else {
return null;
}
}

public T get(String hql, List<Object> param) {
List<T> l = this.find(hql, param);
if (l != null && l.size() > 0) {
return l.get(0);
} else {
return null;
}
}

public Long count(String hql) {
return (Long) this.getCurrentSession().createQuery(hql).uniqueResult();
}

public Long count(String hql, Object[] param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.length > 0) {
for (int i = 0; i < param.length; i++) {
q.setParameter(i, param[i]);
}
}
return (Long) q.uniqueResult();
}

public Long count(String hql, List<Object> param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.size() > 0) {
for (int i = 0; i < param.size(); i++) {
q.setParameter(i, param.get(i));
}
}
return (Long) q.uniqueResult();
}

public Integer executeHql(String hql) {
return this.getCurrentSession().createQuery(hql).executeUpdate();
}

public Integer executeHql(String hql, Object[] param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.length > 0) {
for (int i = 0; i < param.length; i++) {
q.setParameter(i, param[i]);
}
}
return q.executeUpdate();
}

public Integer executeHql(String hql, List<Object> param) {
Query q = this.getCurrentSession().createQuery(hql);
if (param != null && param.size() > 0) {
for (int i = 0; i < param.size(); i++) {
q.setParameter(i, param.get(i));
}
}
return q.executeUpdate();
}

}

package com.java1234.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="t_user")
public class User {

private Integer id;
private String userName;
private String password;

@Id
@GenericGenerator(name = "generator", strategy = "native")
@GeneratedValue(generator = "generator")
@Column(name = "id", length=11)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "userName", length = 20)
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@Column(name = "password", length = 20)
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}

}

package com.java1234.service;

import java.util.List;

import com.java1234.entity.User;

public interface UserService {

public void saveUser(User user);

public void updateUser(User user);

public User findUserById(int id);

public void deleteUser(User user);

public List<User> findAllList();

public User findUserByNameAndPassword(User user);
}

package com.java1234.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.java1234.dao.BaseDao;
import com.java1234.entity.User;
import com.java1234.service.UserService;

@Service("userService") 给service取id
public class UserServiceImpl implements UserService{

@Resource 注入不需要写set 自动注入
private BaseDao<User> baseDao; 与注解的Dao private名字一样

@Override
public void saveUser(User user) {
// TODO Auto-generated method stub
baseDao.save(user);
}

@Override
public void updateUser(User user) {
// TODO Auto-generated method stub
baseDao.update(user);
}

@Override
public User findUserById(int id) {
return baseDao.get(User.class, id);
}

@Override
public void deleteUser(User user) {
baseDao.delete(user);
}

@Override
public List<User> findAllList() {
return baseDao.find("from User"); hql
}

@Override
public User findUserByNameAndPassword(User user) {
return baseDao.get("from User u where u.userName=? and u.password=?", new Object[]{user.getUserName(),user.getPassword()}); 后面的id是对象数组用的是
}

}

】

package com.java1234.action;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.springframework.stereotype.Controller;

import com.java1234.entity.User;
import com.java1234.service.UserService;
import com.opensymphony.xwork2.ActionSupport;

@Controller Struts的bean又由spring管理
public class UserAction extends ActionSupport implements ServletRequestAware{

/**
*
*/
private static final long serialVersionUID = 1L;

private HttpServletRequest request;

@Resource
private UserService userService;

private User user;
private String error;

public User getUser() {
return user;
}

public void setUser(User user) {
this.user = user;
}

public String getError() {
return error;
}

public void setError(String error) {
this.error = error;
}

public String login()throws Exception{
HttpSession session=request.getSession();
User currentUser=userService.findUserByNameAndPassword(user);
if(currentUser!=null){
session.setAttribute("currentUser", currentUser);
return SUCCESS;
}else{
error="用后名或者密码错误！";
return ERROR;
}
}

@Override
public void setServletRequest(HttpServletRequest request) {
// TODO Auto-generated method stub
this.request=request;
}

}

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="${pageContext.request.contextPath }/user/user_login.action" method="post"> 绝对路径 nameSpace 后面是user_login后缀是action
userName:<input type="text" name="user.userName" value="${user.userName }"/><br/> name 对象点属性
password:<input type="password" name="user.password" value="${user.password }"><br/>
<input type="submit" value="login"/><font color="red">${error }</font>
</form>
</body>
</html>

阅读全文

0 0