spring-AOP基础，jdbctemplate基础
AOP-面向切面编程
AOP是对OOP的有益补充，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。
但是在分散代码的同时，也增加了代码的重复性。什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。按面向对象的设计方法，我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的，但就是因为面向对象的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。
我们当然可以将这段代码写在一个独立的类独立的方法里，然后再在这两个类中调用。但是，这样一来，这两个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。那么，有没有什么办法，能让我们在需要的时候，随意地加入代码呢？这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。
一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。
AOP就是这样一种设计思想，常用动态代理来实现，已被广泛应用到各种框架当中，可以把它看做拦截器。
AOP一般使用动态代理思想，java 中的Proxy或者第三方类库cglib来实现，如果不了解动态代理，请参阅:|--------传送门--------||
Spring中的AOP
spring中的AOP使用cglib来实现,通过实现四种不同的接口完成不同的切入。
具体的,1.写一个Bean,该Bean中的某些public非final方法需要被切入2.写一个通用的代理类，实现对应的接口3.配置这两个bean及依赖关系，并配置主代理即class=org.springframework.aop.framework.ProxyFactoryBean。
MethodBeforeAdvice
该接口有一个方法 public void before(Method method, Object[] args, Object target)throws Throwable
method表示切入方法,args表示其参数,target表示要被切入的Bean
重写该方法表示在执行method之前会先执行before()中的代码
AfterReturningAdvice
有方法afterReturning(Object returnValue, Method method, Object[] args, Object target)throws Throwable
同上，重写该方法表示在执行method之后会执行afterReturning()中的代码
ThrowsAdvice
有方法public void afterThrowing(IllegalArgumentException e) throws Throwable
同上，重写该方法表示在执行method时抛出异常IllegalArgumentException会执行afterReturning()中的代码
MethodInterceptor
有方法public Object invoke(MethodInvocation methodInvocation)
通过调用methodInvocation.proceed()执行原方法
实例:
1.写bean
public class CustomerService {
private String name;
private String url;
public void setName(String name) {
this.name = name;
}
public void setUrl(String url) {
this.url = url;
}
public void printName() {
System.out.println("Customer name : " + this.name);
}
public void printURL() {
System.out.println("Customer website : " + this.url);
}
public void printThrowException() {
throw new IllegalArgumentException();
}
}
2.写通用代理
public class LslBeforeMethod implements MethodBeforeAdvice {
public void before(Method arg0, Object[] args, Object target)
throws Throwable {
System.out.println(" Before method ");
}
}
3.配置依赖关系
<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="customerService" class="CustomerService">
<property name="name" value="S" />
<property name="url" value="http://lsl----lsl.com" />
</bean>
<bean id="lslBeforeMethodBean" class="LslBeforeMethod" />
<bean id="customerServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="customerService" />
<property name="interceptorNames">
<list>
<value>lslBeforeMethodBean</value>
</list>
</property>
</bean>
</beans>
之后每次执行CustomerService中的方法都会被LslBeforeMethod进行拦截。
由方法名或正则匹配进行精确切入
上述配置会使所有方法都被拦截，为了更加灵活精准切入，spring准备了多种配置方式。
具体的1.org.springframework.aop.support.DefaultPointcutAdvisor 指默认的总代理 2.pointcut:指定切入点,advice:指定代理
<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="customerService" class=CustomerService">
<property name="name" value="ad" />
<property name="url" value="asd" />
</bean>
<bean id="lslAroundMethodBean" class="LslAroundMethod" />
<bean id="customerServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="customerService" />
<property name="interceptorNames">
<list>
<value>customerAdvisor</value>
</list>
</property>
</bean>
<bean id="customerPointcut" class="org.springframework.aop.support.NameMatchMethodPointcut">
<property name="mappedName" value="printName" />
</bean>
<bean id="customerAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<property name="pointcut" ref="customerPointcut" />
<property name="advice" ref="lslAroundMethodBean" />
</bean>
</beans>
即总代理变成org.springframework.aop.support.DefaultPointcutAdvisor
通过指定pointcut指定切入的方法
通过指定advice指定执行代理
如果要使用正则，则将pointcut变为patterns,即替换为
<property name="patterns">
<list>
<value>.*URL.*</value>
</list>
</property>
AspectJ
可以通过使用注解的形式完成AOP,AspectJ是一个第三方类库，直接静态织入自动生成的代理类。
AspectJ 支持的注解类型如下：
@Before
@Aspect
@After
@AfterReturning
@AfterThrowing
@Around
使用Aspectj可添加依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjtools</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.2</version>
</dependency>
注意更换版本
pom.xml中添加声明<aop:aspectj-autoproxy/>
@Aspect用于声明一个class,表示该class是一个切面class,之后使用注解指定某个class的某个方法，进行静态织入
1.声明普通的bean
@Component("bean")
public class TestMethod {
public void before(String name) {
System.err.println("the param Name is " + name);
}
public void after(String name) {
System.err.println("the param Name is " + name);
}
public void around(String name) {
System.err.println("the param Name is " + name);
}
}
2.声明切面Aspect
@Aspect
@Component
public class ExecutionAspect {
@Before("execution(* club.myapp.aspectJ.*.before*(..))")
public void doBefore(JoinPoint joinPoint) throws Throwable {
System.err.println("这是一个前置通知，在方法调用之前被执行！！！");
}
@After("execution(* club.myapp.aspectJ.*.after*(..))")
public void doAfter(JoinPoint joinPoint) throws Throwable {
System.err.println("这是一个后置通知，在方法调用之后被执行！！！");
}
@Around("execution(* club.myapp.aspectJ.*.around*(..))")
public void doAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.err.println("这是一个环绕通知，在方法调用前后都会执行！！！");
System.err.println("执行前");
joinPoint.proceed();
System.err.println("执行后");
}
}
对于信息"execution(* club.myapp.aspectJ.*.before*(..))"来说: 第一个*表示返回类型(*表示任意类型返回值) 紧跟着某个方法的绝对路径，可使用正则匹配。
JdbcTemplate
Spring中自带的一个封装JDBC加强功能的一个class。
使用时要添加依赖:
<name>springJdbc</name>
<url>http://maven.apache.org</url>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
同时配置数据源，导入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">
<context:annotation-config/>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/test?serverTimezone=UTC"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
使用时创建JdbcTemplate实例即可
JdbcTemplate jdbcTemplate=(JdbcTemplate) context.getBean("jdbcTemplate");
String sql="insert into student values(?,?,?)";
int count=jdbcTemplate.update(sql,new Object[]{2,"shiyanlou2",18});
System.out.println(count);
如上所示,JdbcTemplate内置多种方法执行sql,实际上就是对JDBC进行了进一步的封装
执行查询时可传入一个DAO.class返回RowMapper<DAO>对象进行ORM映射
RowMapper<Student> rowMapper=new BeanPropertyRowMapper<Student>(Student.class);
List<Student> list=jdbcTemplate.query(sql,rowMapper);
for(Student student:list){
System.out.println(student.getId()+" "+student.getName());
}
