public class User {
public void add(){
System.out.println("This is a addMethod...");
}
}
<?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">
<!--配置User对象创建-->
<bean id="user" class="com.ljz.spring5.User"></bean>
</beans>
package com.ljz.spring5.testdemo;
import com.ljz.spring5.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring5 {
@Test
public void testAdd(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
}
<!--配置User对象创建-->
<bean id="user" class="com.ljz.spring5.User"></bean>
key | value |
---|---|
id属性 | 对象的唯一标识 |
class属性 | 类的全路径(包类路径) |
property标签 | 注入属性标签 |
constructor-arg标签 | 构造器标签 |
package com.ljz.spring5;
public class Book {
//创建属性
private String BName;
private String BAuthor;
//set方式注入
public void setBName(String BName) {
this.BName = BName;
}
public void setBAuthor(String BAuthor) {
this.BAuthor = BAuthor;
}
public void testBook(){
System.out.println(BName+"::"+BAuthor);
}
}
<?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">
<!--set方法注入属性-->
<bean id="book" class="com.ljz.spring5.Book">
<!--
在bean标签在使用property完成属性注入
name:类中的属性名称
value:向属性注入的值
-->
<property name="BName" value="数据结构"></property>
<property name="BAuthor" value="严蔚敏"></property>
</bean>
</beans>
@Test
public void testBook(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("BookBean.xml");
//2.获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
book.testBook();
}
package com.ljz.spring5;
/**
* 使用有参数构造注入属性
*/
public class Orders {
//定义属性
private String OName;
private String OAddress;
public Orders(String OName, String OAddress) {
this.OName = OName;
this.OAddress = OAddress;
}
public void testOrders(){
System.out.println(OName+"::"+OAddress);
}
}
<?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="order" class="com.ljz.spring5.Orders">
<constructor-arg name="OName" value="电脑"></constructor-arg>
<constructor-arg name="OAddress" value="China"></constructor-arg>
</bean>
</beans>
@Test
public void testOrders(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("OrderBean.xml");
//2.获取配置创建的对象
Orders order = context.getBean("order", Orders.class);
System.out.println(order);
order.testOrders();
}
1. 使用p名称空间注入,可以简化xml配置方式
2. 第一步:添加p名称空间到配置文件中
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p名称空间注入-->
</beans>
3. 第二步:进行属性注入,在bean标签中进行操作
<!--使用p名称空间注入的类必须包含set方法-->
<bean id="book" class="com.ljz.spring5.Book" p:BName="基础30讲" p:BAuthor="张宇">
</bean>
4. 编写测试代码
@Test
public void testBook2(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("pnspace.xml");
//2.获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
book.testBook();
}
<!--null值-->
<property name="address">
<null/>
</property>
<!--
属性值包含特殊符号
1.把<>进行转义<,>
2.把带特殊符号的内容写到CDATA
-->
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
package com.ljz.spring5.service;
import com.ljz.spring5.dao.UserDao;
public class UserService {
//Spring注入外部bean
//1.创建UserDao属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add.......");
//2.调用update()方法
userDao.update();
//3.编写xml文件
/*
原始方式创建UserDao对象
UserDao userDao = new UserDaoImpl();
userDao.update();
*/
}
}
<?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">
<!--1.service和dao对象的创建-->
<bean id="userService" class="com.ljz.spring5.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.ljz.spring5.dao.UserDaoImpl"></bean>
</beans>
@Test
public void testBean(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("outsidebean.xml");
//2.获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
}
<?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-->
<bean id="emp" class="com.ljz.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="张三"></property>
<property name="gender" value="男"></property>
<!--添加内部bean属性-->
<property name="dept">
<bean id="dept" class="com.ljz.spring5.bean.Dept">
<property name="dname" value="开发部"></property>
</bean>
</property>
</bean>
</beans>
@Test
public void testBean2(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("insidebean.xml");
//2.获取配置创建的对象
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp.toString());
}
<!--级联赋值-->
<bean id="emp" class="com.ljz.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="李四"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.ljz.spring5.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
<!--级联赋值-->
<bean id="emp" class="com.ljz.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="李四"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.ljz.spring5.bean.Dept">
<!-- <property name="dname" value="财务部"></property>-->
</bean>
//使用第二种级联赋值时,必须先获取对象
public Dept getDept() {
return dept;
}
@Test
public void testBean3(){
//1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("cascade.xml");
//2.获取配置创建的对象
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp.toString());
}
package com.ljz.spring5.collectiontype;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
//1.数组类型属性
private String[] courses;
//2.list集String
private List<String> lists;
//3.map集合类型属性
private Map<String,String> maps;
//4.set集String
private Set<String> sets;
public void setSets(Set<String> sets) {
this.sets = sets;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setLists(List<String> lists) {
this.lists = lists;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
//编写测试方法
public void test(){
System.out.println(Arrays.toString(courses));
System.out.println(lists);
System.out.println(maps);
System.out.println(sets);
}
}
<!--1.集合类型属性注入-->
<bean id="stu" class="com.ljz.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>Java课程</value>
<value>数据库课程</value>
</array>
</property>
<!--list类型属性注入-->
<property name="lists">
<list>
<value>张宇</value>
<value>宇哥</value>
</list>
</property>
<!--map类型属性注入-->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PYTHON" value="python"></entry>
</map>
</property>
<!--set类型属性注入-->
<property name="sets">
<set>
<value>MySQL</value>
<value>Redis</value>
</set>
</property>
</bean>
public class TestStu {
@Test
public void testCollection(){
ApplicationContext context = new ClassPathXmlApplicationContext("StuBean.xml");
Stu stu = context.getBean("stu", Stu.class);
stu.test();
}
}
<!--创建多个course对象-->
<bean id="course1" class="com.ljz.spring5.collectiontype.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.ljz.spring5.collectiontype.Course">
<property name="cname" value="MyBatis框架"></property>
</bean>
<!--注入list集合类型,值是对象-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
//学生所以学的多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
//添加test方法的输出
public void test(){
System.out.println(Arrays.toString(courses));
System.out.println(lists);
System.out.println(maps);
System.out.println(sets);
System.out.println(courseList);
}
<?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:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--1 集合类型属性注入-->
</beans>
<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
<value>高等数学</value>
<value>线性代数</value>
<value>数据结构</value>
</util:list>
<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.ljz.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
@Test
public void testCollection2(){
ApplicationContext context = new ClassPathXmlApplicationContext("publicBean.xml");
Book book = context.getBean("book", Book.class);
System.out.println(book.toString());
}
package com.ljz.spring5.factorybean;
import com.ljz.spring5.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {
//定义返回的Bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("Java");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
@Test
public void test3(){
ApplicationContext context = new ClassPathXmlApplicationContext("MyBean.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
<?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="myBean" class="com.ljz.spring5.factorybean.MyBean"></bean>
</beans>
@Test
public void testCollection2(){
ApplicationContext context = new ClassPathXmlApplicationContext("publicBean.xml");
Book book1= context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book1);
System.out.println(book2);
}
//=============================输出结果==========================================
com.ljz.spring5.collectiontype.Book@1dac5ef
com.ljz.spring5.collectiontype.Book@1dac5ef
//=============================修改scope为prototype==========================================
com.ljz.spring5.collectiontype.Book@5c90e579
com.ljz.spring5.collectiontype.Book@58ea606c
package com.ljz.spring5.bean;
//bean的生命周期
public class Orders {
public Orders() {
System.out.println("第一步 执行无参数构造器创建bean实例");
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用set方法设置属性值");
}
//创建执行的初始化方法
public void initMethod(){
System.out.println("第三步 执行初始化方法");
}
//创建对象执行销毁的方法
public void destroyMethod(){
System.out.println("第五步 执行对象销毁方法");
}
}
<!--bean的生命周期-->
<bean id="orders" class="com.ljz.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="iphone"></property>
</bean>
@Test
public void testBean(){
// ApplicationContext context = new ClassPathXmlApplicationContext("OrdersBean.xml");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("OrdersBean.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建的bean实例对象");
System.out.println(orders);
//手动销毁bean
context.close();
}
package com.ljz.spring5.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之后执行的方法");
return bean;
}
}
<!--配置前后置处理器-->
<bean id="myBPP" class="com.ljz.spring5.bean.MyBeanPostProcessor"></bean>
<!--
实现自动转配bean标签属性autowire,配置自动装配
autowire属性值常用两个值:
byName根据属性名称注入,注入值bean的id和类属性名称一致
byType根据属性类型注入
-->
<bean id="emp" class="com.ljz.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.ljz.spring5.autowire.Dept"></bean>
<bean id="emp" class="com.ljz.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.ljz.spring5.autowire.Dept"></bean>
@Test
public void test4(){
ApplicationContext context = new ClassPathXmlApplicationContext("DEBean.xml");
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp);
}
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:33068/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="abc123"></property>
</bean>
prop.driverClass = com.mysql.jdbc.Driver
prop.url = jdbc.mysql://localhost:33068/userDb
prop.userName = root
prop.password = abc123
<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"
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/beans/spring-context.xsd">
2. 在spring配置文件使用标签引入外部属性文件
<!--引入外部文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverclass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<?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"
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">
<!--
开启组件扫描
step1:创建context命名空间
step2: 开启组件扫描,单个包和多个包的写法
单个包,指定包
<context:component-scan base-package="com.ljz.spring5.dao"></context:component-scan>
多个包,两种写法
1.指定多个包
2.指定目录下所有包
指定多个包
<context:component-scan base-package="com.ljz.spring5.dao,com.ljz.spring5.service">
</context:component-scan>
-->
<!--指定目录下的所有包-->
<context:component-scan base-package="com.ljz"></context:component-scan>
package com.ljz.spring5.service;
import org.springframework.stereotype.Component;
//在注解中的value属性值可忽略不写,默认为类名首字母小写
@Component(value = "userService")//等价于<bean id="userService" class="..."/>
public class UserService {
public void add(){
System.out.println("service add....");
}
}
@Test
public void testService(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
<!--
组件扫描配置
use-default-filters="false" 表示现在不使用默认filter,自己配置filter
context:include-filter, 设置扫描内容
-->
<context:component-scan base-package="com.ljz" use-default-filters="false">
<!--
示例一:
type="annotation" 根据注解进行扫描
expression="org.springframework.stereotype.Controller" 只扫描带Controller的类
-->
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--
示例2
context:exclude-filter 设置指定内容不扫描
-->
<context:component-scan base-package="com.ljz">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
//3个最常用的属性注解
@Autowired //根据属性类型进行自动装配
@Qualifier //根据属性名称进行注入
@Resource //可以根据类型注入,可以根据名称注入
@Value //注入普通类型属性
public interface UserDao {
void add();
}
@Repository
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao add....");
}
}
@Service
public class UserService {
//定义dao类型属性,不需要添加set方法,添加注入属性注解
@Autowired //根据类型进行注入
private UserDao userDao;
public void add(){
System.out.println("service add....");
userDao.add();
}
}
@Service
public class UserService {
//定义dao类型属性,不需要添加set方法,添加注入属性注解
@Autowired
@Qualifier(value="userDaoImpl")
private UserDao userDao;
public void add(){
System.out.println("service add....");
userDao.add();
}
}
@Repository(value="userDaoImpl1")//不写value默认userDaoImpl
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao add....");
}
}
@Resource
private UserDao userDao;
@Resource(value = "userDaoImpl1")
private UserDao userDao;
@Repository
public class UserDaoImpl implements UserDao{
@Value(value="小李")
private String name;
@Override
public void add() {
System.out.println("dao add...."+name);
}
}
@Configuration//作为配置类替代xml文件
//包扫描注解等价于<context:component-scan base-package="com.ljz"></context:component-scan>
@ComponentScan(basePackages = {"com.ljz"})
public class SpringConfig {
}
@Test
public void testService2(){
//加载配置类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
创建接口实现类的代理对象,增强类的方法
- 没有接口情况,使用CGLIB动态代理,创建子类代理对象,增强类方法
public interface UserDao {
int add(int a,int b);
String update(String id);
}
public class UserDaoImpl implements UserDao{
@Override
public int add(int a, int b) {
return a+b;
}
@Override
public String update(String id) {
return id;
}
}
package com.ljz.spring5;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class JDKProxy {
public static void main(String[] args) {
//创建接口实现类代理对象
Class[] interfaces = {UserDao.class};
/* //匿名内部类写法
Proxy.newProxyInstance(
JDKProxy.class.getClassLoader(),
interfaces, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
});*/
UserDaoImpl user Dao = new UserDaoImpl();
/*
○ 第一个参数 loader,类加载器
○ 第二个参数 增强方法所在的类,这个类实现的接口,支持多个接口
○ 第三个参数,实现这个接口InvocationHandler,创建代理对象,写增强方法
*/
UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
int add = dao.add(1, 2);
System.out.println(add);
}
}
//创建代理对象
class UserDaoProxy implements InvocationHandler{
//把创建的谁的代理对象,就把谁传递进来,使用有参构造传递
private Object obj;
public UserDaoProxy(Object obj) {
this.obj = obj;
}
//增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前
System.out.println("在方法之前执行...."+method.getName()+":传递的参数..."+ Arrays.toString(args));
//被增强的方法执行
Object res = method.invoke(obj, args);
//方法之后
System.out.println("方法之后执行....."+obj);
return res;
}
}
类的方法中那些可以被动态代理去增强的方法称为连接点
实际开发中已增强的连接点,称为切入点
把通知应用到切入点的过程
execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
execution(* com.ljz.dao.BookDao.add(...)) //*表示任意的访问修饰符
execution(* com.ljz.dao.BookDao.*(...))
execution(* com.;jz.dao.*.*(...))
//被增强的类
public class User {
public void add(){
System.out.println("add....");
}
}
//增强的类
public class UserProxy {
//前置通知
public void before(){
System.out.println("before.....");
}
}
<?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">
<!--开启注解扫描-->
<context:component-scan base-package="com.ljz.spring5.aopanno"></context:component-scan>
</beans>
<!--开启Aspectj生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value="execution(* com.ljz.spring5.aopanno.User.add(..))")
public void before(){
System.out.println("before.....");
}
//最终通知(finally)
@After(value="execution(* com.ljz.spring5.aopanno.User.add(..))")
public void after(){
System.out.println("after......");
}
//返回通知(return)
@AfterReturning(value="execution(* com.ljz.spring5.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning......");
}
//异常通知
@AfterThrowing(value="execution(* com.ljz.spring5.aopanno.User.add(..))")
public void afterThrowing(){
int i =1/0;
System.out.println("afterThrowing......");
}
//环绕通知
@Around(value="execution(* com.ljz.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("around before....");
//被增强方法执行
proceedingJoinPoint.proceed();
System.out.println("around after.....");
}
}
//相同切入点的抽取
@Pointcut(value = "execution(* com.ljz.spring5.aopanno.User.add(..))")
public void pcTest(){
}
//前置通知
//@Before注解表示作为前置通知
@Before(value="pcTest()")
public void before(){
System.out.println("before.....");
}
@Component
@Aspect
@Order(1)
public class PersonProxy
@Configuration
@ComponentScan(basePackages = "com.ljz.spring5")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
//被增强类
public class Book {
//被增强方法
public void buy(){
System.out.println("buy.....");
}
}
//增强类
public class BookProxy {
public void before(){
//增强逻辑
System.out.println("before.....");
}
}
<!--创建两个类的对象-->
<bean id="book" class="com.ljz.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.ljz.spring5.aopxml.BookProxy"></bean>
<!--配置aop的增强-->
<aop:config>
<!--配置切入点-->
<aop:pointcut id="point" expression="execution(* com.ljz.spring5.aopxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--配置增强逻辑入口-->
<aop:before method="before" pointcut-ref="point"></aop:before>
</aop:aspect>
</aop:config>
@Test
public void testAopXml(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.buy();
}
<!--配置数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="url" value="jdbc:mysql://user_db"/>
<property name="username" value="root"/>
<property name="password" value="abc123"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
</bean>
<!--配置JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启组件扫描-->
<context:component-scan base-package="com.ljz"></context:component-scan>
@Service
public class BookService {
//注入dao
@Autowired
private BookDao bookDao;
}
@Repository
public class BookDaoImpl implements BookDao{
//注入jdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
create database user_db character set utf8
use user_db
create table t_user(
user_id int(20) primary key,
user_name varchar(50) not null,
user_status varchar(20) not noll
)
package com.ljz.spring5.eneiey;
public class User {
private String userId;
private String userName;
private String userStatus;
public String getUserId() {
return userId;
}
public String getUserName() {
return userName;
}
public String getUserStatus() {
return userStatus;
}
public void setUserId(String userId) {
this.userId = userId;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setUserStatus(String userStatus) {
this.userStatus = userStatus;
}
}
public interface UserDao {
//添加的方法
void add(User user);
}
@Repository
public class UserDaoImpl implements UserDao{
//注入jdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
//添加方法
@Override
public void add(User user) {
//编写sql语句
String sql = "insert into t_user values(?,?,?)";
//调用方法实现
Object [] args = {user.getUserId(), user.getUserName(), user.getUserStatus()};
int update = jdbcTemplate.update(sql,args);
System.out.println(update);
}
}
@Service
public class UserService {
//注入dao
@Autowired
private UserDao userDao;
//添加的方法
public void addUser(User user){
userDao.add(user);
}
}
@Test
public void testJdbcTemplate(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
User user = new User();
user.setUserId("1");
user.setUserName("小李");
user.setUserStatus("离线");
userService.addUser(user);
}
//修改的方法
void updateUser(User user);
//删除的方法
void delete(String id);
//修改方法
@Override
public void updateUser(User user) {
//编写sql语句
sql = "update t_user set user_name=?,user_status=? where user_id =?";
args = new Object[]{user.getUserName(), user.getUserStatus(),user.getUserId()};
jdbcTemplate.update(sql,args);
}
//删除方法
@Override
public void delete(String id) {
sql = "delete from t_user where user_id = ?";
jdbcTemplate.update(sql,id);
}
//修改操作
User user = new User();
user.setUserId("1");
user.setUserName("小金");
user.setUserStatus("在线");
userService.updateUser(user);
//删除操作
userService.deleteUser("1");
//查找表记录条数
int selectCount();
//查询表记录数
@Override
public int selectCount() {
sql = "select count(*) from t_user";
return jdbcTemplate.queryForObject(sql,Integer.class);
}
//查询表的记录数
public int findCount(){
return userDao.selectCount();
}
//查询记录
System.out.println(userService.findCount());
@Override
public User findUserInfo(String id) {
sql = "select * from t_user where user_id = ?";
//BeanPropertyRowMapper:sping为开发封装好的RowMapper接口的实现类
User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
return user;
}
@Override
public List<User> findAllUser() {
sql = "select * from t_user";
return jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
}
//查询返回集合
System.out.println(userService.findAllUser());
@Override
public void batchAddUser(List<Object[]> batchArgs) {
sql = "insert into t_user values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//批量添加
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3","小张","离线"};
Object[] o2 = {"4","小吴","离线"};
batchArgs.add(o1);
batchArgs.add(o2);
userService.batchAdd(batchArgs);
//批量修改操作
@Override
public void batchUpdateUser(List<Object[]> batchArgs) {
sql = "update t_user set user_name=?,user_status=? where user_id =?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//批量删除
@Override
public void batchDeleteUser(List<Object[]> batchArgs) {
sql = "delete from t_user where user_id = ?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//批量修改
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"小洪123","离线1","4"};
Object[] o2 = {"小吴321","离线2","5"};
batchArgs.add(o1);
batchArgs.add(o2);
userService.batchUpdate(batchArgs);
//删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"4"};
Object[] o2 = {"5"};
batchArgs.add(o1);
batchArgs.add(o2);
userService.batchDelete(batchArgs);
事务的数据库的操作的最基本单元,是逻辑上的一组操作,要么都成功,若有一个失败则所有操作都失败
use user_db;
create table t_account(
id varchar(20) primary key ,
username varchar(50) unique not null ,
money int
);
insert into t_account(id,username,money) values('1','lucy',1000);
insert into t_account(id,username,money) values('2','mary',1000);
@Service
public class UserService {
@Autowired
private UserDao userDao;
}
@Repository
public class UserDaoImpl {
@Autowired
private JdbcTemplate jdbcTemplate;
}
//收入
@Override
public void addMoney() {
String sql = "update t_account set money = money+? where = username = ?";
jdbcTemplate.update(sql,100,"mary");
}
//支出
@Override
public void reduceMoney() {
//lucy转账100给mary
String sql = "update t_account set money = money-? where = username = ?";
jdbcTemplate.update(sql,100,"lucy");
}
//转账的方法
public void transferAccount(){
//lucy支出
userDao.reduceMoney();
//mary收入
userDao.addMoney();
}
@Test
public void testJdbcTemplate(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.transferAccount();
}
@Service
public class UserService {
@Autowired
private UserDao userDao;
//转账的方法
public void transferAccount(){
//lucy支出
userDao.reduceMoney();
//模拟异常
int i = 10/0;
//mary收入
userDao.addMoney();
}
}
//转账的方法
public void transferAccount(){
try{
//step1 开启事务
//step2 进行业务操作
userDao.reduceMoney();//lucy支出
int i = 10/0;//模拟异常
userDao.addMoney(); //mary收入
//step3 没有发生异常,提交事务
}catch(Exception e){
//step4 出现异常,事务回滚(还原初始状态)
}
}
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
public void setDataSource(@Nullable DataSource dataSource) {
if (dataSource instanceof TransactionAwareDataSourceProxy) {
// If we got a TransactionAwareDataSourceProxy, we need to perform transactions
// for its underlying target DataSource, else data access code won't see
// properly exposed transactions (i.e. transactions for the target DataSource).
this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();
}
else {
this.dataSource = dataSource;
}
}
<?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/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">
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager">
</tx:annotation-driven>
@Service
@Transactional //Spring注解声明式管理事务,该注解可用于类/方法上
public class UserService {}
- required_new--如果当前方法必须启动新事务,并在新事务内运行,若有事务在运行,将其挂起
- supports--如果事务在运行,当前方法就在这个事务内运行,否则不能运行在事务中
- not_supports--当前方法不应该运行在事务中,运行事务时,将其挂起
- mandatory--当前方法必须在事务中运行,若没有正在运行的事务,抛出异常
- never--当前方法不应该运行在事务中,如有事务运行,抛出异常
- nested--如有事务运行,当前方法就应该在这个事务的嵌套事务中运行,否则启动一个新事务,并在自己的事务内运行
@Service
//Spring注解声明式管理事务,该注解可用于类/方法上
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {}
面试题:MySQL如何解决不可重复读和幻读现象?
在Spring配置文件中进行配置
<!--1.创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--注入数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--2.配置通知-->
<tx:advice id="notice">
<tx:attributes>
<!--指定在那种规则的方法上添加事务-->
<tx:method name="transferAccount" propagation="REQUIRED"/>
<!--<tx:method name="transfer*"/>-->
</tx:attributes>
</tx:advice>
<!--3.配置切入点和切面-->
<aop:config>
<!--配置切入点-->
<aop:pointcut id="pt" expression="execution(* com.ljz.spring5.service.UserService.*(..))"/>
<!--配置切面-->
<aop:advisor advice-ref="notice" pointcut-ref="pt"/>
</aop:config>
@Configuration//配置类
@ComponentScan(basePackages = "com.ljz")//开启主键扫描
@EnableTransactionManagement//开启事务
public class SpringTransactionConfig {
//创建数据库连接池
@Bean
public DruidDataSource getDataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:33068/user_db?characterEncoding=utf-8");
dataSource.setUsername("root");
dataSource.setPassword("abc123");
return dataSource;
}
//创建jdbcTemplate对象
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource){
//在getDataSource()执行完成之后ioc容器中就存在DataSource对象,形参直接从ioc容器中获取
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//注入DataSource
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
//创建事务管理器对象
@Bean
public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}