[Java] 初学者,Spring快速入门

Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation)

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

<!--指定Spring配置文件的位置，有多个配置文件时，以逗号分隔-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <!--spring将加载spring目录下的applicationContext.xml文件-->
  <param-value>
    classpath:spring/applicationContext.xml
  </param-value>
</context-param>
<!--指定以ContextLoaderListener方式启动Spring容器-->
<listener>
  <listener-class>
    org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>

<?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="user" class="com.wyl.pojo.User">
    <property name="name" value="王延领"/>
  </bean>
</beans>

public class User { 
  private String name; 
  public User() {
    System.out.println("user无参构造方法");
  } 
  public void setName(String name) {
    this.name = name;
  } 
  public void show(){
    System.out.println("name="+ name );
  }
}

@Test
public void test(){
  ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  //在执行getBean的时候, user已经创建好了 , 通过无参构造
  User user = (User) context.getBean("user");
  //调用对象的方法 .
  user.show();
}

• Properties 配置文件主要以 key-value 键值对的形式存在，只能赋值，不能进行其他操作，适用于简单的属性配置。
  
• XML 配置文件是树形结构，相对于 Properties 文件来说更加灵活。XML 配置文件结构清晰，但是内容比较繁琐，适用于大型复杂的项目。
  

<!-- 1. 默认构造函数，如果类中没有默认构造函数则无法创建对象;bean标签中只有id和class就默认使用构造函数创建对象 -->
<bean id="userService" class="com.wyl.pojo.User"/>

<!-- 第一种根据index参数下标设置 -->
<bean id="userService" class="com.wyl.pojo.User">
  <!-- index指构造方法 , 下标从0开始 -->
  <constructor-arg index="0" value="wyl"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userService" class="com.wyl.pojo.User">
  <!-- name指参数名 -->
  <constructor-arg name="name" value="wyl"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userService" class="com.wyl.pojo.User">
  <constructor-arg type="java.lang.String" value="wyl"/>
</bean>

<!-- 2. 使用工厂中的方法创建对象;工厂中有一个方法可以创建对象，先创建工厂对象，通过factory-bean指向工厂，使用factory-method方法获取对象 -->
<bean id="beanFactory" class="org.factory.BeanFactory"/>
<bean id="userService" factory-bean="beanFactory" factory-method="getUserService"/>

<!-- 3. 使用静态工厂中的静态方法创建对象 -->
<bean id="userService" class="org.factory.StaticBeanFactory" factory-method="getUserService"/>

<!--  别名 : 如果添加了别名，我们也可以使用别名获取到这个对象 -->
<alias name="User" alias="u1"></alias>

<!--
bean标签常用属性：
id属性：起名称，id属性值名称任意命名，不能包含特殊符号
class属性：创建对象所在类的全路径
name属性：功能和id属性一样的，但是在name属性值里面可以包含特殊符号
scope属性
singleton：默认值，单例
prototype：多例
request：创建对象把对象放到request域里面
session：创建对象把对象放到session域里面
globalSession：创建对象把对象放到globalSession里面
-->
<bean id="UserT" class="com.wyl.pojo.User" scope="singleton" name="u2 u21,u22;u23">
  <property name="name" value="123"/>
</bean>

<import resource="beans.xml"/>

<bean id="..." class="..." scope="singleton"/>

• Spring 启动，查找并加载需要被 Spring 管理的 Bean，并实例化 Bean。
  
• 利用依赖注入完成 Bean 中所有属性值的配置注入。
  
• 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
  
• 如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
  
• 如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
  
• 如果 Bean 实现了 [BeanPostProcessor] 接口，则 Spring 调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。
  
• 如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
  
• 如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
  
• 如果 [BeanPostProcessor ]和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。
  
• 如果在 中指定了该 Bean 的作用域为 singleton，则将该 Bean 放入 Spring IoC 的缓存池中，触发 Spring 对该 Bean 的生命周期管理； 如果在 中指定了该 Bean 的作用域为 prototype，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。
  
• 如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法销毁 Bean；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。
  

public class UserBean {
private String name;  
  
  public UserBean(){  
    System.out.println("UserBean()构造函数");  
  }  
  public String getName() {  
    return name;  
  }  
  public void setName(String name) {  
    System.out.println("setName()");  
    this.name = name;  
  }  
  public void init(){  
    System.out.println("this is init of UserBean");  
  }  
  
  public void destory(){  
    System.out.println("this is destory of UserBean " + this);  
  }  
}

<bean id="user_singleton" class="com.wyl.userBean" scope="singleton" 
init-method="init" destroy-method="destory" lazy-init="true"/>

<beans default-lazy-init="true">

public class LifeTest {
@Test 
public void test() {
AbstractApplicationContext container = 
new ClassPathXmlApplicationContext("user.xml");
UserBean user = (UserBean)container.getBean("user_singleton");
System.out.println(user);
container.close();
}
}

UserBean()构造函数
this is init of UserBean
com.wyl.UserBean@573f2bb1
……
this is destory of UserBeancom.wyl.UserBean@573f2bb1

<bean id="user_prototype" class="com.bean.UserBean" scope="prototype" init-method="init" destroy-method="destroy"/>

public class UserTest {
@Test 
public void test() {
AbstractApplicationContext container = new ClassPathXmlApplicationContext("User.xml");
UserBean User1 = (UserBean)container.getBean("User_singleton");
System.out.println(User1);
UserBean User2 = (UserBean)container.getBean("User_prototype");
System.out.println(User2);
container.close();
}
}

UserBean()构造函数
this is init of UserBean
com.wyl.UserBean@573f2bb1
LifeBean()构造函数
this is init of UserBean
com.wyl.UserBean@5ae9a829
……
this is destory of lifeBean com.wyl.UserBean@573f2bb1

private String name;
private Integer age;
private Date birthday;
// 构造函数
public UserServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}

<!-- name：按字段名称辅助；index：字段索引，给第几个字段赋值；type：指定注入值的类型，该类型也是构造函数中某个或某些字段的类型； -->
<!-- value:要注入的值，基本类型和String；ref：注入其他类型数据，指向外部bean对象;这个外部bean需要存在于Spring容器 -->
<bean id="userService" class="org.service.impl.UserServiceImpl">
  <constructor-arg name="name" value="张三"/>
  <constructor-arg name="age" value="12"/>
  <constructor-arg name="birthday" ref="date"/>
</bean>
<!-- 创建日期对象 -->
<bean id="date" class="java.util.Date"/>

private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
  this.name = name;
}
public void setAge(Integer age) {
  this.age = age;
}
public void setBirthday(Date birthday) {
  this.birthday = birthday;
}

<bean id="userService2" class="org.service.impl.UserServiceImpl2">
  <property name="name" value="李四"/>
  <property name="age" value="12"/>
  <property name="birthday" ref="date"/>
</bean>
<!-- 创建日期对象 -->
<bean id="date" class="java.util.Date"/>

<!-- 注入对象类型属性 -->
<!-- 1 配置service和dao对象 -->
<bean id="userDao" class="cn.ioc.UserDao"></bean>
<bean id="userService" class="cn.ioc.UserService">
  <!-- 注入dao对象-->
  <property name="userDao" ref="userDao"></property>
</bean>

<!-- 注入复杂类型属性值 -->
<bean id="person" class="cn.property.Person">
  <!-- 数组 -->
  <property name="arrs">
   <list>
     <value>小王</value>
     <value>小马</value>
     <value>小宋</value>
   </list>
  </property>
  
  <!-- list -->
  <property name="list">
   <list>
     <value>小奥</value>
     <value>小金</value>
     <value>小普</value>
   </list>    
  </property>
  <!-- map -->
  <property name="map">
   <map>
     <entry key="aa" value="lucy"></entry>
     <entry key="bb" value="mary"></entry>
     <entry key="cc" value="tom"></entry>
   </map>
  </property>
  <!-- properties -->
  <property name="properties">
   <props>
     <prop key="driverclass">com.mysql.jdbc.Driver</prop>
     <prop key="username">root</prop>
   </props>
  </property>
</bean>
<!--set-->
<property name="set">
      <set>
        <value>LOL</value>
        <value>COC</value>
        <value>WOW</value>
      </set>
</property>
<!--null-->
<property name="marne">
      <null/>
</property>

<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:c="http://www.springframework.org/schema/c"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
  https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

<!-- p命名空间注入，可以直接注入属性的值：property -->
<bean id="User"  class="com.wyl.pojo.User" p:name ="老秦" p:age ="18"/>

<!-- c命名空间注入，通过构造器注入：construct-args -->
<bean id="User2" class="com.wyl.pojo.User" c:age="18" c:name="老李"/>

• 在xml中显示的配置
  
• 在java中显示配置
  
• 隐式的自动装配bean
  

<!--
byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
-->
<bean id="people" class="com.wyl.pojo.People" autowire="byName">
  <property name="name" value="wangyanling"/>
</bean>

<bean id="cat" class="com.wyl.pojo.Cat"/>
  <bean id="dog" class="com.wyl.pojo.Dog"/>
  <!--
  byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
  byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
  -->
  <bean id="people" class="com.wyl.pojo.People" autowire="byType">
    <property name="name" value="WANGAYNLING"/>
  </bean>

• 导入约束 context约束
  
• 配置注解的支持： context:annotation-config/
  

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

@Autowired
  private Cat cat;
  @Autowired
  private Dog dog;

@Nullable   // 字段标记了这个注解，说明这个字段可以为null

public class People {
  private String name;
  @Autowired
  @Qualifier("cat")
  private Cat cat;
  @Autowired
  @Qualifier("dog")
  private Dog dog;
}

public class People {
  private String name;
  @Resource(name = "cat")
  private Cat cat;
  @Resource(name = "dog")
  private Dog dog;

• @Autowired与@Resource异同：
  
• @Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。
  
• @Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用
  
• @Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是 需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。
  

• @Component（标注当前类是Spring容器中的一个组件）
  
• @Repository（一般用于持久层）
  
• @Service（一般用于业务层）
  
• @Controller（一般用于表现层）
  

• @Autowired：自动按类型注入，常用在变量上；如果容器中有唯一一个类型与注解的变量类型相同则可以自动注入成功。当有多个bean匹配则按照变量名称去查找，找不到则注入失败。
  
• @Qualifier("userDaoImpl")：结合@Autowired使用，注入指定名称的bean；在类的成员变量上不能单独使用；在方法参数里使用可以单独使用；
  
• @Resource：相当于@Autowired自动注入，而@Resource（name="xxx"）注入指定的bean，相当于同时使用@Autowired和@Qualifier("userDaoImpl")两个注解。
  

• @Value：注入基本数据类型和String类型。指定数据的值，写法：${表达式}。
  

@PostConstruct
public void init() {
  System.out.println("初始化注解");
}
@PreDestroy
public void destroy() {
  System.out.println("销毁注解");
}

• @Configuration：作用在类上面标明当前类是一个配置类
  
• @ComponentScan(basePackages = "com.wyl")：扫描包注解：相当于下面这一行配置
  

<!--<context:component-scan base-package="com.wyl"/>-->

• @Bean：在配置类中写在方法上，将方法返回的对象注入到Spring容器中。该注解的方法有参数时，会去容器中找bean对象，跟@Autowired注解一样的。
  
• @PropertySource("classpath:db.properties")：指定数据库配置文件的位置
  
• @Import：存在多个配置文件，用该注解引入其他配置文件。
  

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ApplicationConfig.class) 纯注解
// @ContextConfiguration(locations = "classpath:ApplicationContext.xml") xml配置文件
public class SpringTest {
  @Autowired
  private AccountServiceImpl accountService;
  @Test
  public void findAll(){
    List<Account> accountList = accountService.findAll();
    for (Account account : accountList) {
      System.out.println(account);
    }
  }
 
}

public class User {
  private Integer id;
  private String name;
}

<?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="user" class="com.wyl.bean.User" >
    <property name="id" value="1"></property>
    <property name="name" value="wyl"></property>
  </bean>
</beans>

@test
public void UserTest{
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("Bean.xml");
    User userInfo=(User)context.getBean("user");
    System.out.println(userInfo);
}

@Configuration
public class MyTestConfig {
  //bean的id默认为方法名
  @Bean
  public User user(){
    User user =new User();
    user.setName("王延领");
    user.setId(2);
    return user;
  }
}
@test
public void UserTest{
  AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(MyTestConfig.class);
    User userInfo=(User)context.getBean("user");
    System.out.println(userInfo.toString());
    }

• 静态代理，手动去实现一个代理类
  
• 动态代理，通过反射动态的实现代理类
  

• 1.抽象角色 : 一般使用接口或者抽象类来实现
  

public interface Rent {
  public void rent();
}

• 2.真实角色 : 被代理的角色
  

public class Host implements Rent{
  @Override
  public void rent() {
    System.out.println("房东出租房子！");
  }
}

• 3.代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
  

public class Proxy {
  private Host host;
  public Proxy(){
  }
  public Proxy(Host host){
    this.host=host;
  }
  public void rent(){
    seeHouse();
    host.rent();
    hetong();
    fare();
  }
  public void seeHouse(){
    System.out.println("中介带你看房");
  }
  public void fare(){
    System.out.println("收中介费!");
  }
  public void hetong(){
    System.out.println("签租领合同");
  } 
}

• 4.客户 : 使用代理角色来进行一些操作 .
  

public class Client {
  public static void main(String[] args) {
    Host host=new Host();
    //host.rent();
    Proxy proxy=new Proxy(host);
    proxy.rent();
  }
}

• 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
  
• 公共的业务由代理来完成 . 实现了业务的分工 ,
  
• 公共业务发生扩展时变得更加集中和方便 .
  

• 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .
  

• 基于接口的动态代理----JDK动态代理
  

//抽象角色：租房
public interface Rent {
  public void rent();
}
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
  public void rent() {
    System.out.println("房屋出租");
  }
}
//代理:中介
public class ProxyInvocationHandler implements InvocationHandler {
  private Rent rent;
  public void setRent(Rent rent) {
    this.rent = rent;
  }
  //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
  public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),
        rent.getClass().getInterfaces(),this);
  }
  // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
  // 处理代理实例上的方法调用并返回结果
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    seeHouse();
    //核心：本质利用反射实现！
    Object result = method.invoke(rent, args);
    fare();
    return result;
  }
  //看房
  public void seeHouse(){
    System.out.println("带房客看房");
  }
  //收中介费
  public void fare(){
    System.out.println("收中介费");
  }
}
//租客
public class Client {
  public static void main(String[] args) {
    //真实角色
    Host host = new Host();
    //代理实例的调用处理程序
    ProxyInvocationHandler pih = new ProxyInvocationHandler();
    pih.setRent(host); //将真实角色放置进去！
    Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
    proxy.rent();
  }
}

• 基于类的动态代理Ccglib
  

// 被代理的对象
Account account = new Account();
Account o = (Account) Enhancer.create(account.getClass(), new MethodInterceptor() {
  /**
  * 被代理对象的方法执行前会执行
  * @param obj 被代理的对象
  * @param method 方法
  * @param objects 参数
  * @param methodProxy 当前执行方法的代理的对象
  * @return 和被代理对象的方法相同的返回值
  * @throws Throwable 异常
  */
  @Override
  public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    System.out.println("增强前...");
    Object invoke = method.invoke(account, objects);
    System.out.println("增强后...");
    return invoke;
  }
});
o.findAll();

• Joinpoint（连接点）：指的是方法，可以被动态代理增强的方法就是连接点，Spring只支持方法类型的连接点
  
• Pointcut（切入点）：定义要对哪些Joinpoint连接点（方法）进行拦截增强功能。被增强的方法叫做切入点，所有的方法都可以看做是一个连接点。只有被增强了的方法才叫做切入点。
  
• Advice（通知/增强）：拦截到Jointpoint（连接点）之后要做的事情就是通知。通知的类型：前置通知、后置通知、最终通知、环绕通知、异常通知。
  
• Introduction（引介）：一种特殊的通知，在不修改代码的前提下，可以在运行期为类动态的添加一些方法或字段。
  
• Target（目标对象）：代理的目标对象
  
• Weaving（织入）：是把增强 应用到 目标对象来创建新的代理对象的过程（添加新功能代码的过程）。Spring采用的是动态代理织入，而AspectJ采用编译期和类装载织入。
  
• Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。
  
• Aspect（切面）：是切入点和通知（引介）的结合。
  

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>

//接口与业务
public interface UserService {
  public void add();
  public void delete();
  public void update();
  public void search();
} 
public class UserServiceImpl implements UserService{
  @Override
  public void add() {
    System.out.println("增加用户");
  }
  @Override
  public void delete() {
    System.out.println("删除用户");
  }
  @Override
  public void update() {
    System.out.println("更新用户");
  }
  @Override
  public void search() {
    System.out.println("查询用户");
  }
}

//增强
public class AfterLog implements AfterReturningAdvice {
  //returnValue 返回值
  //method被调用的方法
  //args 被调用的方法的对象的参数
  //target 被调用的目标对象
  @Override
  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("执行了" + target.getClass().getName()
    +"的"+method.getName()+"方法,"
    +"返回值："+returnValue);
  }
}

<?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"
   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">
  <!--注册bean-->
  <bean id="userService" class="com.wyl.service.UserServiceImpl"/>
  <bean id="log" class="com.kuang.log.Log"/>
  <bean id="afterLog" class="com.kuang.log.AfterLog"/>
  <!--aop的配置-->
  <aop:config>
    <!--切入点  expression:表达式匹配要执行的方法-->
    <aop:pointcut id="pointcut" expression="execution(* com.wyl.service.UserServiceImpl.*(..))"/>
    <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
  </aop:config>
</beans>

public class MyTest {
  @Test
  public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = (UserService) context.getBean("userService");
    userService.search();
  }
}

//切入类
public class DiyPointcut {
  public void before(){
    System.out.println("---------方法执行前---------");
  }
  public void after(){
    System.out.println("---------方法执行后---------");
  }
  
}

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.wyl.config.DiyPointcut"/
<!--aop的配置-->
<aop:config>
  <!--第二种方式：使用AOP的标签实现-->
  <aop:aspect ref="diy">
    <aop:pointcut id="diyPonitcut" expression="execution(* com.wyl.service.UserServiceImpl.*(..))"/>
    <aop:before pointcut-ref="diyPonitcut" method="before"/>
    <aop:after pointcut-ref="diyPonitcut" method="after"/>
  </aop:aspect>
</aop:config>

public class MyTest {
  @Test
  public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
  }
}

//注解实现的增强类
package com.wyl.config;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointcut {
  @Before("execution(* com.wyl.service.UserServiceImpl.*(..))")
  public void before(){
    System.out.println("---------方法执行前---------");
  }
  @After("execution(* com.wyl.service.UserServiceImpl.*(..))")
  public void after(){
    System.out.println("---------方法执行后---------");
  }
  @Around("execution(* com.wyl.service.UserServiceImpl.*(..))")
  public void around(ProceedingJoinPoint jp) throws Throwable {
    System.out.println("环绕前");
    System.out.println("签名:"+jp.getSignature());
    //执行目标方法proceed
    Object proceed = jp.proceed();
    System.out.println("环绕后");
    System.out.println(proceed);
  }
}

// Spring自带的数据源
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai");
dataSource.setUsername("root");
dataSource.setPassword("root");
JdbcTemplate template = new JdbcTemplate(dataSource);
List<Account> accountList = template.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
for (Account account : accountList) {
  System.out.println(account);
}

@Autowired
private JdbcTemplate jdbcTemplate;
// 添加
@Test
public void insert(){
  String sql = "insert into account(name, money) VALUES (?,?)";
  Account account1 = new Account();
  account1.setName("迪迦");
  account1.setMoney(10000F);
  jdbcTemplate.update(sql, account1.getName(), account1.getMoney());
  find();
}
// 删除
@Test
public void delete(){
  String sql = "delete from account where id = ?";
  jdbcTemplate.update(sql, 6);
  find();
}
// 更新
@Test
public void update(){
  List<Account> accounts = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<>(Account.class), 1);
  Account account = accounts.get(0);
  account.setName("泰罗");
  String sql = "update account set name = ? where id = ?";
  jdbcTemplate.update(sql, account.getName(),account.getId());
  find();
}
// 查询所有
@Test
public void find(){
  List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
  for (Account account : accountList) {
    System.out.println(account);
  }
}
// 查询一个bean
@Override
public Account findByName(String name) {
  String sql = "select * from account where name = ?";
  return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Account.class), name);
}
// 查询一个Object
@Test
public void findOne(){
  String sql = "select count(id) from account";
  Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
  System.out.println(integer);
}

• 声明式事务管理：
  

1、配置事务管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/></bean>
2、配置通知
<!-- 配置事务的通知/增强 -->
<tx:advice id="interceptor">
  <!-- 配置事务的属性 -->
  <!-- isolation:事务隔离级别，默认使用数据库的隔离级别
     no-rollback-for：指定一个异常，除了该异常都回滚。
     propagation:事务传播行为，默认是required一定有事务，增删改设置required，查询设置supports
     read-only：是否只读。只有查询才能设置true。默认是false支持读写。
     rollback-for：指定一个异常，出现该异常就回滚，其他异常不回滚。
     timeout：事务超时时间，默认-1，永不超时。指定了以秒为单位。 -->
  <tx:attributes>
    <!-- 指定在哪种规则的方法上添加事务 -->
    <tx:method name="transfer*"/>
  </tx:attributes>
</tx:advice>
3、事务管理器和切入点表达式关联起来
<aop:config>
  <!-- service包下所有类的所有方法都添加事务 -->
  <aop:pointcut id="commonPointcut" expression="execution(* com.sample.service.*.*(..))"/>
  <!-- 将事务管理器和切入点表达式关联起来 -->
  <aop:advisor advice-ref="interceptor" pointcut-ref="commonPointcut"/>
</aop:config>

1、配置事务管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/></bean>
2、开启对事务注解的支持
<!-- 开启对事务注解的支持 -->
<tx:annotation-driven/>
3、在要添加事物的类上添加注解：@Transactional

@Configuration
@ComponentScan("com.sample")
// 相当于<tx:annotation-driven/>
@EnableTransactionManagement
@PropertySource("classpath:db.properties")
public class AppConfig {
  @Value("${db.driver}")
  private String driver;
  @Value("${db.url}")
  private String url;
  @Value("${db.username}")
  private String username;
  @Value("${db.password}")
  private String password;
  @Bean
  public DruidDataSource dataSource(){
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName(driver);
    dataSource.setUrl(url);
    dataSource.setUsername(username);
    dataSource.setPassword(password);
    return dataSource;
  }
  @Bean
  public JdbcTemplate jdbcTemplate(){
    return new JdbcTemplate(dataSource());
  }
  @Bean
  public DataSourceTransactionManager transactionManager(){
    return new DataSourceTransactionManager(dataSource());
  }
}
==========
在类上添加@Transactional注解即可

• 编程式事务管理：通过代码去实现事务的管理，手动开启事务、提交、回滚。