Spring-3

来源：互联网发布：大数据分析方法现状编辑：程序博客网时间：2024/05/17 19:19

spring day02回顾

AOP ：切面编程

切面：切入点和通知结合

spring aop 编程

<aop:config>

方法1：

<aop:pointcut expression="切入点表达式" id="">

<aop:advisor advice-ref="通知引用" pointcut-ref="切入点的引用">

方法2：

<aop:advisor advice-ref="通知引用" pointcut="切入点表达式">

AspectJ xml

<aop:config>

<aop:aspect ref="切面类">

<aop:pointcut>

<aop:before> 前置

<aop:afterReturning returning="第二个参数名称"> 后置

<aop:around> 环绕

<aop:afterThrowing throwing="第二。。。"> 抛出异常

<aop:after> 最终

AspectJ annotation

@Aspect

@Pointcut("表达式") private void xxx(){}

@Before @...

切入点表达式

<aop:pointcut expression="execution(* com.itheima.crm.*.service..*.*(..))" id="">

事务管理
1. 回顾事务

事务：一组业务操作ABCD，要么全部成功，要么全部不成功。
特性：ACID

原子性：整体

一致性：完成

隔离性：并发

持久性：结果

隔离问题：

脏读：一个事务读到另一个事务没有提交的数据

不可重复读：一个事务读到另一个事务已提交的数据（update）

虚读(幻读)：一个事务读到另一个事务已提交的数据（insert）

隔离级别：

read uncommitted：读未提交。存在3个问题

read committed：读已提交。解决脏读，存在2个问题

repeatable read：可重复读。解决：脏读、不可重复读，存在1个问题。

serializable ：串行化。都解决，单事务。

mysql 事务操作--简单

ABCD 一个事务

Connection conn = null;

try{

//1 获得连接

conn = ...;

//2 开启事务

conn.setAutoCommit(false);

//3 提交事务

conn.commit();

} catche(){

//4 回滚事务

conn.rollback();

}

mysql 事务操作--Savepoint

需求：AB（必须），CD（可选）

Connection conn = null;

Savepoint savepoint = null; //保存点，记录操作的当前位置，之后可以回滚到指定的位置。（可以回滚一部分）

try{

//1 获得连接

conn = ...;

//2 开启事务

conn.setAutoCommit(false);

savepoint = conn.setSavepoint();

//3 提交事务

conn.commit();

} catche(){

if(savepoint != null){ //CD异常

// 回滚到CD之前

conn.rollback(savepoint);

// 提交AB

conn.commit();

} else{ //AB异常

// 回滚AB

conn.rollback();

}

1. 事务管理介绍
  1. 导入jar包

transaction --> tx

1. 1. 三个顶级接口

PlatformTransactionManager 平台事务管理器，spring要管理事务，必须使用事务管理器

进行事务配置时，必须配置事务管理器。

TransactionDefinition：事务详情（事务定义、事务属性），spring用于确定事务具体详情，

例如：隔离级别、是否只读、超时时间等

进行事务配置时，必须配置详情。spring将配置项封装到该对象实例。

TransactionStatus：事务状态，spring用于记录当前事务运行状态。例如：是否有保存点，事务是否完成。

spring底层根据状态进行相应操作。

1. 1. PlatformTransactionManager 事务管理器

导入jar包：需要时平台事务管理器的实现类

常见的事务管理器

DataSourceTransactionManager ，jdbc开发时事务管理器，采用JdbcTemplate

HibernateTransactionManager，hibernate开发时事务管理器，整合hibernate

api详解

TransactionStatus getTransaction(TransactionDefinition definition) ，事务管理器通过“事务详情”，获得“事务状态”，从而管理事务。

void commit(TransactionStatus status) 根据状态提交

void rollback(TransactionStatus status) 根据状态回滚

1. 1. TransactionStatus

1. 1. TransactionDefinition

传播行为：在两个业务之间如何共享事务。

PROPAGATION_REQUIRED , required , 必须【默认值】

支持当前事务，A如果有事务，B将使用该事务。

如果A没有事务，B将创建一个新的事务。

PROPAGATION_SUPPORTS ，supports ，支持

支持当前事务，A如果有事务，B将使用该事务。

如果A没有事务，B将以非事务执行。

PROPAGATION_MANDATORY，mandatory ，强制

支持当前事务，A如果有事务，B将使用该事务。

如果A没有事务，B将抛异常。

PROPAGATION_REQUIRES_NEW ， requires_new ，必须新的

如果A有事务，将A的事务挂起，B创建一个新的事务

如果A没有事务，B创建一个新的事务

PROPAGATION_NOT_SUPPORTED ，not_supported ,不支持

如果A有事务，将A的事务挂起，B将以非事务执行

如果A没有事务，B将以非事务执行

PROPAGATION_NEVER ，never，从不

如果A有事务，B将抛异常

如果A没有事务，B将以非事务执行

PROPAGATION_NESTED ，nested ，嵌套

A和B底层采用保存点机制，形成嵌套事务。

掌握：PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED

1. 案例：转账
  1. 搭建环境
    1. 创建表

create database ee19_spring_day03;

use ee19_spring_day03;

create table account(

id int primary key auto_increment,

username varchar(50),

money int

);

insert into account(username,money) values('jack','10000');

insert into account(username,money) values('rose','10000');

2. 1. 导入jar包

核心：4+1
aop ： 4 (aop联盟、spring aop、aspectj规范、spring aspect)
数据库：2 （jdbc/tx）
驱动：mysql
连接池：c3p0

2. 1. dao层

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

@Override

public void out(String outer, Integer money) {

this.getJdbcTemplate().update("update account set money = money - ? where username = ?", money,outer);

}

@Override

public void in(String inner, Integer money) {

this.getJdbcTemplate().update("update account set money = money + ? where username = ?", money,inner);

}

2. 1. service层

public class AccountServiceImpl implements AccountService {

private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {

this.accountDao = accountDao;

}

@Override

public void transfer(String outer, String inner, Integer money) {

accountDao.out(outer, money);

//断电

// int i = 1/0;

accountDao.in(inner, money);

}

2. 1. spring配置

</bean>

</bean>

</bean>

2. 1. 测试

@Test

public void demo01(){

String xmlPath = "applicationContext.xml";

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);

AccountService accountService = (AccountService) applicationContext.getBean("accountService");

accountService.transfer("jack", "rose", 1000);

}

1. 1. 手动管理事务（了解）

spring底层使用 TransactionTemplate 事务模板进行操作。
操作

1.service 需要获得 TransactionTemplate

2.spring 配置模板，并注入给service

3.模板需要注入事务管理器

4.配置事务管理器：DataSourceTransactionManager ，需要注入DataSource

2. 1. 修改service

//需要spring注入模板

private TransactionTemplate transactionTemplate;

public void setTransactionTemplate(TransactionTemplate transactionTemplate) {

this.transactionTemplate = transactionTemplate;

}

@Override

public void transfer(final String outer,final String inner,final Integer money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus arg0) {

accountDao.out(outer, money);

//断电

// int i = 1/0;

accountDao.in(inner, money);

}

});

}

2. 1. 修改spring配置

</bean>

</bean>

</bean>

1. 1. 工厂bean 生成代理：半自动

spring提供管理事务的代理工厂bean TransactionProxyFactoryBean

1.getBean() 获得代理对象

2.spring 配置一个代理

2. 1. spring配置

<!-- 4 service 代理对象

4.1 proxyInterfaces 接口

4.2 target 目标类

4.3 transactionManager 事务管理器

4.4 transactionAttributes 事务属性（事务详情）

prop.key ：确定哪些方法使用当前事务配置

prop.text:用于配置事务详情

格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception

传播行为隔离级别是否只读异常回滚异常提交

例如：

<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT</prop> 默认传播行为，和隔离级别

<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT,readOnly</prop> 只读

<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT,+java.lang.ArithmeticException</prop>有异常扔提交

-->

<props>

<prop key="transfer">PROPAGATION_REQUIRED,ISOLATION_DEFAULT</prop>

</props>

</property>

</bean>

</bean>

2. 1. 测试

1. 1. AOP 配置基于xml【掌握】

在spring xml 配置aop 自动生成代理，进行事务的管理

1.配置管理器

2.配置事务详情

3.配置aop

</bean>

<!-- 4.2 事务详情（事务通知），在aop筛选基础上，对ABC三个确定使用什么样的事务。例如：AC读写、B只读等

<tx:attributes> 用于配置事务详情（属性属性）

<tx:method name=""/> 详情具体配置

propagation 传播行为， REQUIRED：必须；REQUIRES_NEW:必须是新的

isolation 隔离级别

-->

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

<tx:attributes>

<tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.itheima.service..*.*(..))"/>

</aop:config>

1. 1. AOP配置基于注解【掌握】

1.配置事务管理器，将并事务管理器交予spring
2.在目标类或目标方法添加注解即可 @Transactional

2. 1. spring配置

</bean>

<!-- 4.2 将管理器交予spring

* transaction-manager 配置事务管理器

* proxy-target-class

true ：底层强制使用cglib 代理

-->

<tx:annotation-driven transaction-manager="txManager"/>

2. 1. service 层

@Transactional

public class AccountServiceImpl implements AccountService {

2. 1. 事务详情配置

@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)

public class AccountServiceImpl implements AccountService {

整合Junit

导入jar包

基本：4+1

测试：spring-test...jar

1.让Junit通知spring加载配置文件

2.让spring容器自动进行注入

修改测试类

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations="classpath:applicationContext.xml")

public class TestApp {

@Autowired //与junit整合，不需要在spring xml配置扫描

private AccountService accountService;

@Test

public void demo01(){

// String xmlPath = "applicationContext.xml";

// ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);

// AccountService accountService = (AccountService) applicationContext.getBean("accountService");

accountService.transfer("jack", "rose", 1000);

}

整合web

0.导入jar包

spring-web.xml

1.tomcat启动加载配置文件

servlet --> init(ServletConfig) --> <load-on-startup>2

filter --> init(FilterConfig) --> web.xml注册过滤器自动调用初始化

listener --> ServletContextListener --> servletContext对象监听【】

spring提供监听器 ContextLoaderListener --> web.xml <listener><listener-class>....

如果只配置监听器，默认加载xml位置：/WEB-INF/applicationContext.xml

2.确定配置文件位置，通过系统初始化参数

ServletContext 初始化参数 web.xml

<context-param>

<param-name>contextConfigLocation

<param-value>classpath:applicationContext.xml

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

3.从servletContext作用域获得spring容器（了解）

// 从application作用域（ServletContext）获得spring容器

//方式1：手动从作用域获取

ApplicationContext applicationContext =

(ApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

//方式2：通过工具获取

ApplicationContext apppApplicationContext2 =

WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());

SSH整合
1. jar整合

struts：2.3.15.3

hibernate : 3.6.10

spring: 3.2.0

1. 1. struts

struts-2.3.15.3\apps\struts2-blank\WEB-INF\lib

模板技术，一般用于页面静态化

freemarker：扩展名：*.ftl

velocity ：扩展名 *.vm

1. 1. spring

基础：4+1 ， beans、core、context、expression ， commons-logging (struts已经导入)
AOP：aop联盟、spring aop 、aspect规范、spring aspect
db：jdbc、tx
测试：test
web开发：spring web

驱动：mysql
连接池：c3p0

整合hibernate：spring orm

1. 1. hibernate

%h%\hibernate3.jar 核心

%h%\lib\required 必须

%h%\lib\jpa jpa规范（java persistent api 持久api），hibernate注解开发 @Entity @Id 等

整合log4j

导入 log4j...jar (struts已经导入)

整合（过渡）：slf4j-log4j12-1.7.5.jar

二级缓存

核心：ehcache-1.5.0.jar

依赖：

backport-util-concurrent-2.1.jar

commons-logging (存在)

1. 1. 整合包

spring整合hibernate： spring orm
struts 整合spring：struts2-spring-plugin-2.3.15.3.jar

删除重复jar包

1. spring整合hibernate：有hibernate.cfg.xml
  1. 创建表

create table t_user(

id int primary key auto_increment,

username varchar(50),

password varchar(32),

age int

);

1. 1. PO 类

javabean

public class User {

private Integer id;

private String username;

private String password;

private Integer age;

映射文件

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

</class>

</hibernate-mapping>

1. 1. dao层

spring提供 HibernateTemplate 用于操作PO对象，类似Hibernate Session对象。

public class UserDaoImpl implements UserDao {

//需要spring注入模板

private HibernateTemplate hibernateTemplate;

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

this.hibernateTemplate = hibernateTemplate;

}

@Override

public void save(User user) {

this.hibernateTemplate.save(user);

}

1. 1. service层

public class UserServiceImpl implements UserService {

private UserDao userDao;

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

@Override

public void register(User user) {

userDao.save(user);

}

1. 1. hibernate.cfg.xml

<session-factory>

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

<property name="hibernate.connection.url">jdbc:mysql:///ee19_spring_day03</property>

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

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

<property name="hibernate.current_session_context_class">thread</property>

</session-factory>

1. 1. applicationContext.xml
    1. 添加命名空间

<?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:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="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/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

2. 1. 加载hibernate配置文件

<!-- 1 加载hibenrate.cfg.xml 获得SessionFactory

* configLocation确定配置文件位置

-->

</bean>

<!-- 2创建模板

* 底层使用session，session 有sessionFactory获得

-->

</bean>

2. 1. dao和service

</bean>

</bean>

2. 1. 事务管理

</bean>

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

<tx:attributes>

<tx:method name="register"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.itheima.service..*.*(..))"/>

</aop:config>

1. 1. 测试

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations="classpath:applicationContext.xml")

public class TestApp {

@Autowired

private UserService userService;

@Test

public void demo01(){

User user = new User();

user.setUsername("jack");

user.setPassword("1234");

user.setAge(18);

userService.register(user);

}

1. spring整合hibernate：没有hibernate.cfg.xml 【】

删除hibernate.cfg.xml文件，但需要保存文件内容，将其配置spring中
修改dao层，继承HibernateDaoSupport

1. 1. 修改spring，配置SessionFactory

</bean>

<!-- 1.3配置 LocalSessionFactoryBean，获得SessionFactory

* configLocation确定配置文件位置

1)dataSource 数据源

2)hibernateProperties hibernate其他配置项

3) 导入映射文件

mappingLocations ，确定映射文件位置，需要“classpath:” ,支持通配符【】

mappingResources ，加载执行映射文件，从src下开始。不支持通配符*

mappingDirectoryLocations ，加载指定目录下的，所有配置文件

mappingJarLocations ，从jar包中获得映射文件

-->

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>

<prop key="hibernate.hbm2ddl.auto">update</prop>

<prop key="hibernate.current_session_context_class">thread</prop>

</props>

</property>

</bean>

1. 1. 修改dao，使用HibernateDaoSupport

继承HibernateDaoSupport

// 底层需要SessionFactory，自动创建HibernateTemplate模板

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

@Override

public void save(User user) {

this.getHibernateTemplate().save(user);

}

spring 删除模板，给dao注入SessionFactory

</bean>

1. struts整合spring：spring创建action

1.编写action类，并将其配置给spring ，spring可以注入service

2.编写struts.xml

3.表单jsp页面

4.web.xml 配置

1.确定配置文件contextConfigLocation

2.配置监听器 ContextLoaderListener

3.配置前端控制器 StrutsPrepareAndExecuteFitler

1. 1. action类

通用

public class UserAction extends ActionSupport implements ModelDriven<User> {

//1 封装数据

private User user = new User();

@Override

public User getModel() {

return user;

}

//2 service

private UserService userService;

public void setUserService(UserService userService) {

this.userService = userService;

}

功能

/**

* 注册

* @return

public String register(){

userService.register(user);

return "success";

}

1. 1. spring配置

</bean>

1. 1. struts配置

<result name="success">/messag.jsp</result>

</action>

</package>

</struts>

1. 1. jsp表单

用户名：<input type="text" name="username"/> <br/>

密码：<input type="password" name="password"/> <br/>

年龄：<input type="text" name="age"/> <br/>

</form>

1. 1. 配置web.xml

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

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

1. struts整合spring：struts创建action 【】

删除spring action配置
struts <action class="全限定类名">

<result name="success">/messag.jsp</result>

</action>

</package>

要求：Action类中，必须提供service名称与 spring配置文件一致。（如果名称一样，将自动注入）

分析：

1. struts 配置文件

default.properties ,常量配置文件

struts-default.xml ，默认核心配置文件

struts-plugins.xml ，插件配置文件

struts.xml，自定义核心配置文件

常量的使用，后面配置项，将覆盖前面的。

2.default.properties ，此配置文件中确定按照【名称】自动注入

/org/apache/struts2/default.properties

3. struts-plugins.xml ,struts整合spring

struts的action将有spring创建

总结，之后action有spring创建，并按照名称自动注入

要求

阅读全文

0 0

Spring-3

spring day02回顾

事务管理

回顾事务

事务管理介绍

导入jar包

三个顶级接口

PlatformTransactionManager 事务管理器

TransactionStatus

TransactionDefinition

案例：转账

搭建环境

创建表

导入jar包

dao层

service层

spring配置

测试

手动管理事务（了解）

修改service

修改spring配置

工厂bean 生成代理：半自动

spring配置

测试

AOP 配置基于xml【掌握】

AOP配置基于注解【掌握】

spring配置

service 层

事务详情配置

整合Junit

整合web

SSH整合

jar整合

struts

spring

hibernate

整合包

spring整合hibernate：有hibernate.cfg.xml

创建表

PO 类

dao层

service层

hibernate.cfg.xml

applicationContext.xml

添加命名空间

加载hibernate配置文件

dao和service

事务管理

测试

spring整合hibernate：没有hibernate.cfg.xml 【】

修改spring，配置SessionFactory

修改dao，使用HibernateDaoSupport

struts整合spring：spring创建action

action类

spring配置

struts配置

jsp表单

配置web.xml

struts整合spring：struts创建action 【】

要求