Spring基础（3）

Spring进阶

1. 基于AspectJ的注解AOP

使用注解方式实现AOP操作

（1）创建对象

<bean id="book" class="cn.spring.web.action.Book">

<bean id="myBook" class="cn.spring.web.action.MyBook">

（2）开启AOP操作的自动代理

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<context:component-scan base-package="cn.spring.web"

（3）在增强类上使用注解完成AOP操作

代码：

@Aspect

public class MyBook{

// 在方法上使用注解完成增强配置

@Before(value="execution(* cn.spring.web.action.Book.*(..))")

public void before1(){

System.out.println("before");

}

}

2. Spring的JdbcTemplate操作

Spring对不同对持久化层技术都进行了封装

1. JdbcTemplate对jdbc进行了封装

2. 实现CRUD操作

（1）导入JdbcTemplate使用对Jar包

spring-jdbc-4.2.4-RELAEASE.jar

spring-tx-4.2.4-RELEASE.jar

（2）创建对象，设置数据库信息

// 设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql:///spring");

dataSource.setUsername("root");

dataSource.setPassword("root");

（3）创建JdbcTemplate对象，设置数据源

// 创建JdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

（4）调用JdbcTemplate里对方法实现操作

// 调用JdbcTemplate对象里的方法实现操作

String sql = "insert into user values(?,?)";

jdbcTemplate.update(sql, "Admin","123");

String sql ="update user set username=? where username=?";

jdbcTemplate.update(sql, "admin","Admin");

String sql ="delete from user where username=?";

jdbcTemplate.update(sql, "admin");

（5）JdbcTemplate实现查询

使用接口RowMapper，JdbcTemplate针对这个接口没有实现类，得到不同类型的数据需要自己进行封装

（a）查询返回某一个值

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

String sql = "select count(*) from user";

Integer count = jdbcTemplate.queryForObject(sql, Integer.class);

（b）查询返回对象

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

String sql = "select * from user where username=?";

User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "tom");

System.out.println(user);

// 定义RowMapper的实现类

class MyRowMapper implements RowMapper<User>{

@Override

public User mapRow(ResultSet rs, int num) throws SQLException {

// 从结果集中获取数据

String username = rs.getString("username");

String password = rs.getString("password");

// 将数据封装到对象中

User user = new User();

user.setPassword(password);

user.setUsername(username);

return user;

}

}

（c）查询返回list集合

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

String sql = "select * from user";

List<User> user = jdbcTemplate.query(sql, new MyRowMapper());

System.out.println(user);

3. Spring配置连接池

1. 配置c3p0连接池

（1）导入c3p0的jar包

mchange-commons-java-0.2.3.4.jar

c3p0-0.9.2.1.jar

（2）创建Spring配置文件，配置连接池

<!-- 配置c3p0的连接池 -->

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<!-- 注入属性值 -->

<property name="driverClass" value="com.mysql.jdbc.Driver"></property>

<property name="jdbcUrl" value="jdbc:mysql:///spring"></property>

<property name="user" value="root"></property>

<property name="password" value="root"></property>

</bean>

2. service和dao注入操作

（1）创建service和dao对象，在Service中注入了dao对象

<!-- 配置属性 -->

<bean id="userDao" class="cn.spring.c3p0.UserDao"></bean>

<bean id="userService" class="cn.spring.c3p0.UserService">

<property name="userDao" ref="userDao"></property>

</bean>

（2）创建JdbcTemplate对象，并注入到dao中

<!-- 配置属性 -->

<bean id="userDao" class="cn.spring.c3p0.UserDao">

<!-- 注入JdbcTemplate对象 -->

<property name="jdbcTemplate" ref="jdbcTemplate"></property>

</bean>

（3）在JdbcTemplate中注入dataSource

<!-- 创建JdbcTemplate对象 -->

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<!-- 将dataSource传递到JdbcTemplate中 -->

<property name="dataSource" ref="dataSource"></property>

</bean>

4. Spring事务管理

1. 事务概念

2. Spring进行事务管理API

（1）Spring事务管理的两种方式：

（a）编程式事务管理（不用）

（b）声明式事务管理

基于XML配置文件

基于注解方式

（2）主要的API

（1）接口PlatformTransactionManager事务管理器

Spring为不同的持久层框架提供了不同的实现类

Spring JDBC：DataSourceTransactionManager

Hibernate：HibernateTransactionManager

(3) 首先配置事务管理器

应用：

搭建转账环境

（1）创建数据库表

User Account

（2）创建Service和Dao以及注入关系

<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/context http://www.springframework.org/schema/context/spring-context.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">

<!-- 配置c3p0的连接池 -->

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<!-- 注入属性值 -->

<property name="driverClass" value="com.mysql.jdbc.Driver"></property>

<property name="jdbcUrl" value="jdbc:mysql:///spring"></property>

<property name="user" value="root"></property>

<property name="password" value="root"></property>

</bean>

<!-- 对象创建 -->

<bean id="orderService" class="cn.spring.transaction.service.OrderService">

<!-- 注入orderDao -->

<property name="orderDao" ref="orderDao"></property>

</bean>

<bean id="orderDao" class="cn.spring.transaction.dao.OrderDao">

<!-- 注入JdbcTemplate模版对象 -->

<property name="jdbcTemplate" ref="jdbcTemplate"></property>

</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<!-- 将DataSource传递到JdbcTemplate中 -->

<property name="dataSource" ref="dataSource"></property>

</bean>

</beans>

3. Spring进行事务配置(声明式)

（1）基于XML配置文件

使用AOP思想进行配置

（a）配置事务管理器

<!-- 配置事务管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!-- 注入dataSource -->

<property name="dataSource" ref="dataSource"></property>

</bean>

（b）配置事务增强

<!-- 配置事务增强 -->

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

<!-- 做事务操作 -->

<tx:attributes>

<!-- 设置进行事务操作方法的规则 -->

<tx:method name="doAccount" propagation="REQUIRED"/>

</tx:attributes>

</tx:advice>

（c）配置切面、切入点

<!-- 配置切入点、切面 -->

<aop:config>

<!-- 切入点 -->

<aop:pointcut expression="execution(* cn.spring.transaction.service.OrderService.*(..))" id="pointcut1"/>

<!-- 切面 -->

<aop:advisor advice-ref="reAdvice" pointcut-ref="pointcut1"/>

</aop:config>

（2）基于注解方式

（a）配置事务管理器

<!-- 配置事务管理器 -->

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!-- 注入dataSource -->

<property name="dataSource" ref="dataSource"></property>

</bean>

（b）配置事务注解

<!-- 开启事务注解 -->

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

（c）在要使用事务的方法所在的类上添加注解

@Transactional

public class OrderService {

private OrderDao orderDao;

public void setOrderDao(OrderDao orderDao) {

this.orderDao = orderDao;

}

public void doAccount(){

orderDao.descSalary();

// 出现异常

int i = 1/0;

orderDao.incrSalary();

}

}