这是黑马视频的学习笔记
一、
基于AspectJ的注解实现AOP操作1.1 导入Spring基本JAR包
1.2 创建被增强类和增强类
- 被增强类Book,实例注解方式创建Book Bean
package com.spring.annotationAOP;
import org.springframework.stereotype.Component;
@Component("book")
public class Book {
public void add(){
System.out.println("book add...");
}
}
增强类Mybook,实例注解方式创建Book Bean
在增强类上需要添加@Aspect注解
- 在增强的方法上需要添加下面五种注解声明通知方法
- @Before – 前置增强
- @Before – 后置增强
- @AfterReturning – 后置增强
- @AfterThrowing –抛出异常后增加
- @Around –前后增强
package com.spring.annotationAOP;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component("myBook")
@Aspect
public class Mybook {
@Autowired
private Book book;
@After("execution(* com.spring.annotationAOP.Book.*(..))")
//使用注解方式,表达式添加切入点
public void afterAdd(){
System.out.println("mybook add...");
}
}
1.3 配置Spring核心文件bean3.xml
- 需要开启AOP自动代理
- 需要添加相应的schema约束(aop,context)
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" 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"> <!-- bean definitions here -->
<!-- 开启注解扫描,在包里面扫描类、方法、属性上面是否有注解 -->
<context:component-scan base-package="com.spring.annotationAOP"></context:component-scan>
<!-- 开启AOP自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
1.4 测试代码
package test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.annotationAOP.Book;
public class AOPannotationTest {
@Test
public void testAopAnnotation(){
ApplicationContext context = new ClassPathXmlApplicationContext("aopAnnotation.xml");
Book book = (Book) context.getBean("book");
book.add();
}
}
二、 Spring 中的JDBCTemplate对JDBC进行了封装
2.1 添加相关的JAR包
spring-jdbc,spring-tx(事务),mysql驱动包
2.2 创建对象,设置数据库信息
DriverManagerDataSource source = new DriverManagerDataSource();
source.setDriverClassName("com.mysql.cj.jdbc.Driver");
source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
source.setUsername("root");
source.setPassword("666666");
- 1
- 2
- 3
- 4
- 5
2.3 创建JDBCTemplate对象,设置数据库
JdbcTemplate template = new JdbcTemplate(source);
2.4 调用JDBCTemplate对象里面的方法实现操作
String sql = "insert into grade value(?,?,?)";
int row = template.update(sql,5,"C++高级班","数据库操作"); //返回的是数据库影响行数
- 1
- 2
2.5 实现增删改操作
package test;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class TestJDBC {
JdbcTemplate template;
public void upload(){
//设置数据库信息
DriverManagerDataSource source = new DriverManagerDataSource();
source.setDriverClassName("com.mysql.jdbc.Driver");
source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
source.setUsername("root");
source.setPassword("");
//创建JDBCTemplate对象,设置数据源
JdbcTemplate template = new JdbcTemplate(source);
}
@Test//添加操作
public void add(){
upload();
//调用JDBCTemplate对象里面的方法实现操作
String sql = "insert into grade value(?,?,?)";//创建SQL语句
int row = template.update(sql,5,"C++高级班","数据库操作");
System.out.println(row);
//返回的是数据库影响行数
}
@Test
//修改操作
public void update(){
upload();
String sql = "update grade set GNAME=? where GID=?";
int row = template.update(sql,"C#",5);
System.out.println(row);
}
@Test//删除操作
public void delete(){
upload();
String sql = "delete from grade where GID=?";
int row = template.update(sql,5);
System.out.println(row);
}
}
2.6 实现查询功能
2.6.1 查询单个
@Test//获取表中数据个数操作
public void count(){
upload();
String sql = "select count(*) from grade";
int row = template.queryForObject(sql, Integer.class);
System.out.println(row);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
2.6.2 查询单个对象
将数据库中的查询结果转换成类对象
1. 创建Grade类
package com.spring.jdbc;
public class Grade {
private int gid;
private String gName;
private String gDesc;
public String getgDesc() {
return gDesc;
}
public void setgDesc(String gDesc) {
this.gDesc = gDesc;
}
public String getgName() {
return gName;
}
public void setgName(String gName) {
this.gName = gName;
}
public int getGid() {
return gid;
}
public void setGid(int gid) {
this.gid = gid;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "[GName:]"+gName+",[GDesc:]"+gDesc;
}
}
- 2
4. 测试类的整体代码
package test;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import com.spring.jdbc.Grade;
public class TestJDBC {
JdbcTemplate template;
public void upload(){
//设置数据库信息
DriverManagerDataSource source = new DriverManagerDataSource();
source.setDriverClassName("com.mysql.jdbc.Driver");
source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
source.setUsername("root");
source.setPassword("");
//创建JDBCTemplate对象,设置数据源
template = new JdbcTemplate(source);
}
@Test//添加操作
public void add(){
upload();
//调用JDBCTemplate对象里面的方法实现操作
String sql = "insert into grade value(?,?,?)";//创建SQL语句
int row = template.update(sql,5,"C++高级班","数据库操作");
System.out.println(row);
//返回的是数据库影响行数
}
@Test
//更新操作
public void update(){
upload();
String sql = "update grade set GNAME=? where GID=?";
int row = template.update(sql,"C#",5);
System.out.println(row);
}
@Test//删除操作
public void delete(){
upload();
String sql = "delete from grade where GID=?";
int row = template.update(sql,5);
System.out.println(row);
}
@Test//获取表中数据个数操作
public void count(){
upload();
String sql = "select count(*) from grade";
int row = template.queryForObject(sql, Integer.class);//返回类型的class
System.out.println(row);
}
//查询某个对象
@Test
public void getObject(){
upload();
String sql = "select * from grade where gid=?";
rade grade = template.queryForObject(sql, new MyRowMapper(), 4);//返回对象的方法,第二个参数是一个接口
//
System.out.println(grade);
}
//接口的实现类
class MyRowMapper implements RowMapper<Grade>{ @Override//实现接口里面的方法 public Grade mapRow(ResultSet arg0, int arg1) throws SQLException { Grade grade = new Grade();//从结果集中得到数据,封装到对象里面 grade.setgName(arg0.getString("GName")); grade.setgDesc(arg0.getString("GDesc")); return grade; }}
}
2.6.3 查询list集合
//查询list集合
@Test
public void getList(){
upload();
String sql = "select * from grade ";
List<Grand> list = template.query(sql, new MyRowMapper());//返回对象的方法,第二个参数是一个接口
//
System.out.println(list);
}
三、spring配置连接池和dao使用jdbcTemplate
3.1 spring配置C3P0连接池
导入jar包(c3p0包和mchange-commons-java包)=====》在spring核心配置文件里配置连接池
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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">
<!-- 创建连接池 配置连接池的属性值 -->
<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/c3p0jdbctemplate"></property>
<property name="user" value="root"></property>
<property name="password" value="666666"></property>
</bean>
<!-- dao中注入jdbctemplate对象 -->
<bean id="dao" class="org.dao.Dao">
<property name="jdbcTemplate" ref="jdbctemplate"></property>
</bean>
<!-- service中注入dao对象 -->
<bean id="service" class="org.service.Service">
<property name="dao" ref="dao"></property>
</bean>
<!-- 创建jdbctemplate对象 并且向其中注入连接池对象 dateSource是该对象中数据源的属性 -->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"></property>
</bean>
</beans>
3.2 dao使用jdbcTemplate
先创建service类。
package org.service;
import org.dao.*;
public class Service {
//想在service中调用dao对象的add方法 创建dao对象 生成对应的set方法
private Dao dao;
//生成set方法 注入dao对象
public void setDao(Dao dao){
this.dao=dao;
}
public void add(){
dao.add();
}
}
再创建Dao类,在类中使用jdbcTemplate
package org.dao;
import java.beans.PropertyVetoException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class Dao {
private JdbcTemplate jdbcTemplate;
//设置set方法 为了之后的注入
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void add(){
String sql="insert into User(name,password) values(?,?)";
jdbcTemplate.update(sql,"joke2",520);
System.out.println("增加了一条信息。。。。。。。");
}
}
配置文件的代码
<!-- dao中注入jdbctemplate对象 -->
<bean id="dao" class="org.dao.Dao">
<property name="jdbcTemplate" ref="jdbctemplate"></property>
</bean>
<!-- service中注入dao对象 -->
<bean id="service" class="org.service.Service">
<property name="dao" ref="dao"></property>
</bean>
<!-- 创建jdbctemplate对象 并且向其中注入连接池对象 dateSource是该对象中数据源的属性 -->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"></property>
</bean>
测试代码
package org.test;
import org.junit.Test;
import org.service.Service;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestDemo {
public static void main(String args[]){
ApplicationContext ac=new ClassPathXmlApplicationContext("bean3.xml");
Service s=(Service) ac.getBean("service");
s.add();
}
}
四、spring的事务操作
4.1事务概念
隔离性:多个事务之间互不影响
4.2 spring事务管理的api
1.编程式事务管理(不用)
2.声明式事务管理(常用),可以用配置文件,也可以用注解(常用)
3.api
接口:Spring事务管理的核心接口是PlatformTransactionManager
Spring提供了许多内置事务管理器实现:
- DataSourceTransactionManager:位于org.springframework.jdbc.datasource包中,数据源事务管理器,提供对单个javax.sql.DataSource事务管理,用于Spring JDBC抽象框架、iBATIS或MyBatis框架的事务管理;
- JdoTransactionManager:位于org.springframework.orm.jdo包中,提供对单个javax.jdo.PersistenceManagerFactory事务管理,用于集成JDO框架时的事务管理;
- JpaTransactionManager:位于org.springframework.orm.jpa包中,提供对单个javax.persistence.EntityManagerFactory事务支持,用于集成JPA实现框架时的事务管理;
- HibernateTransactionManager:位于org.springframework.orm.hibernate3包中,提供对单个org.hibernate.SessionFactory事务支持,用于集成Hibernate框架时的事务管理;该事务管理器只支持Hibernate3+版本,且Spring3.0+版本只支持Hibernate 3.2+版本;
- JtaTransactionManager:位于org.springframework.transaction.jta包中,提供对分布式事务管理的支持,并将事务管理委托给Java EE应用服务器事务管理器;
- OC4JjtaTransactionManager:位于org.springframework.transaction.jta包中,Spring提供的对OC4J10.1.3+应用服务器事务管理器的适配器,此适配器用于对应用服务器提供的高级事务的支持;
- WebSphereUowTransactionManager:位于org.springframework.transaction.jta包中,Spring提供的对WebSphere 6.0+应用服务器事务管理器的适配器,此适配器用于对应用服务器提供的高级事务的支持;
- WebLogicJtaTransactionManager:位于org.springframework.transaction.jta包中,Spring提供的对WebLogic 8.1+应用服务器事务管理器的适配器,此适配器用于对应用服务器提供的高级事务的支持。
4.3配置事务管理器
搭建转账环境:先建数据库和表=====》创建service和dao类,完成注入关系=====
创建service类和dao类, 完成注入关系的代码
package cn.itcast.service;
import cn.itcast.dao.OrderDao;
public class OrderService {
private OrderDao orderDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
}
package cn.itcast.dao;
import org.springframework.jdbc.core.JdbcTemplate;
public class OrderDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
}
spring核心配置文件代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.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 "
default-autowire="byName">
<!-- 配置C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
<!-- 注入属性值 -->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day03-tx"></property>
<property name="user" value="root"></property>
<property name="password" value="666666"></property>
</bean>
<bean id="orderService" class="cn.itcast.service.OrderService">
<property name="orderDao" ref="orderDao"></property>
</bean>
<bean id="orderDao" class="cn.itcast.dao.OrderDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
====》转账逻辑的代码:===》
package cn.itcast.dao;
import org.springframework.jdbc.core.JdbcTemplate;
public class OrderDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void lessMoney() {
String sql="updat account set salary=salary-1000 where username=?";
jdbcTemplate.update(sql,1000,"小王");
}
public void moreMoney() {
String sql="updat account set salary=salary+1000 where username=?";
jdbcTemplate.update(sql,1000,"小 马");
}
}
package cn.itcast.service;
import cn.itcast.dao.OrderDao;
public class OrderService {
private OrderDao orderDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
public void zhuanZhang() {
orderDao.lessMoney();
orderDao.moreMoney();
}
}
====》添加事务操作(声明式,xml配置文件,少用)
配置事务管理器的代码
<!-- 配置C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
<!-- 注入属性值 -->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day03-tx"></property>
<property name="user" value="root"></property>
<property name="password" value="666666"></property>
</bean>
<!--配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</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="account*"/>
</tx:attributes>
</tx:advice>
配置切面的代码:
<!-- 配置C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
<!-- 注入属性值 -->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day03-tx"></property>
<property name="user" value="root"></property>
<property name="password" value="666666"></property>
</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="account*"/>
</tx:attributes>
</tx:advice>
<!--配置切面 -->
<aop:config>
<!--配置切入点 -->
<aop:pointcut expression="execution(*cn.itcast.service.OrderService.*(..))" id="pointcut1"/>
<!--切面 -->
<aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/>
</aop:config>
=======》注解方式添加事务
配置事务管理器代码和开启事务注解代码
<!-- 配置C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
<!-- 注入属性值 -->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day03-tx"></property>
<property name="user" value="root"></property>
<property name="password" value="666666"></property>
</bean>
<!--配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启事务注解扫描 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
被增加事务功能的方法的类的代码
@Transactional
public class OrderService {
private OrderDao orderDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
public void zhuanZhang() {
orderDao.lessMoney();
orderDao.moreMoney();
}
}