注解配置Bean
Spring的 IOC 容器检查到注解就会生成对象，但这个注解的具体含义不会识别
配置自动扫描的包
<!--配置容器要扫描的包1. component-scan 要对指定包下的类进行扫描, 并创建对象到容器2. base-package 指定要扫描的包3. 含义是当spring容器创建/初始化时，就会扫描com.hspedu.spring.component包下的所有的 有注解 @Controller / @Service / @Respository / @Component类将其实例化，生成对象，放入到ioc容器--><context:component-scan base-package="com.hspedu.spring.component"/>
Map里的默认id是类名开头小写
com.hspedu.spring.component会扫描comonent及其子包
如果要扫描spring下的包，写成com.hspedu.spring.*
只扫描包下的哪些类
在xml中加上 resource-pattern="User*.class" 表示只扫描spring.component 和它的子包下的User打头的类，用的比较少
<context:component-scan base-package="com.hspedu.spring.component"
resource-pattern="User*.class" />排除包下某种类型的注解(注解方式)
<!--需求：如果我们希望排除某个包/子包下的某种类型的注解，可以通过exclude-filter来指定1. context:exclude-filter 指定要排除哪些类2. type 指定排除方式 annotation表示按照注解来排除3. expression="org.springframework.stereotype.Service" 指定要排除的注解的全路径--><context:component-scan base-package="com.hspedu.spring.component"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/></context:component-scan>指定自动扫描哪些注解类(注解方式)
<!--需求：如果我们希望按照自己的规则，来扫描包/子包下的某些注解, 可以通过 include-filter1. use-default-filters="false" 表示不使用默认的过滤机制/扫描机制2. context:include-filter 表示要去扫描哪些类3. type="annotation" 按照注解方式来扫描/过滤4. expression="org.springframework.stereotype.Service" 指定要扫描的注解的全路径--><context:component-scan base-package="com.hspedu.spring.component" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/><context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/></context:component-scan>
使用 value 指定 id 值
覆盖默认的id值
注解默认 类名首字母小写 作为id值
@Service(value = "sss")
public class Student {
}自动装配
@AutoWired
IOC容器中有多个对象，要进行查找
1、是否有唯一bean
2、根据id查找根据id查找没找到，报错原因：按id找不到，按类型有多个，类型匹配不上
根据唯一性查找，属性名无所谓，直接按照类型找到
IOC容器中的对象和装配的对象哈希值不一定一样
<!--自动扫描的id就是类名首字母小写或者指定value的id值--><context:component-scanbase-package="com.hspedu.spring.component"/><!--配置两个UserService对象--><bean class="com.hspedu.spring.component.UserService" id="userService200"/><bean class="com.hspedu.spring.component.UserService" id="userService300"/>@Controller
public class UserAction {@Autowiredprivate UserService userService200;public void sayOk() {System.out.println("userAction 装配的 userService属性=" + userService);userService200.hi();}
}@Qualifier与@AutoWired
必须搭配使用，相当于@Resource
@Resource
按照name的值在容器中查找，属性名没有作用了
按照type类型查找，属性名没有作用了，要求在容器里只能有一个这样类型的对象
如果没有指定name和type，则先试用byName注入策略，如果匹配不上，再使用byType策略
泛型依赖装配
使用Autowired
把PhoneDao对象装配到PhoneService，通过泛型传入BaseDao，再把指定的泛型对象装配到PhoneService
动态代理
不改变原有代码的情况下进行对象功能增强，使用代理对象拓展功能
public interface Vehicle {public void run();public String fly(int height);
}public class Car implements Vehicle{@Overridepublic void run() {//System.out.println("交通工具开始运行了....");System.out.println("小汽车在路上 running....");//System.out.println("交通工具停止运行了....");}@Overridepublic String fly(int height) {System.out.println("小汽车可以飞翔 高度=" + height);return "小汽车可以飞翔 高度=" + height;}
}类似切面类
public class VehicleProxyProvider {//target_vehicle 表示真正要执行的对象//该对象的类实现了Vehicle接口private Vehicle target_vehicle;public VehicleProxyProvider(Vehicle target_vehicle) {this.target_vehicle = target_vehicle;}//编写一个方法，可以返回一个代理对象, 该代理对象可以通过反射机制调用到被代理对象的方法public Vehicle getProxy() {ClassLoader classLoader =target_vehicle.getClass().getClassLoader();//得到对象的接口信息Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();//创建InvocationHandler 对象//因为 InvocationHandler 是接口，所以我们可以通过匿名对象的方式来创建该对象/**** public interface InvocationHandler {* public Object invoke(Object proxy, Method method, Object[] args)* throws Throwable;* }* invoke 方法是将来执行我们的target_vehicle的方法时，会调用到**/InvocationHandler invocationHandler = new InvocationHandler() {/*** invoke 方法是将来执行我们的target_vehicle的方法时，会调用到* @param o 表示代理对象* @param method 就是通过代理对象调用方法时，的哪个方法 代理对象.run()* @param args : 表示调用 代理对象.run(xx) 传入的参数* @return 表示 代理对象.run(xx) 执行后的结果.* @throws Throwable*/@Overridepublic Object invoke(Object o, Method method, Object[] args)throws Throwable {System.out.println("交通工具开始运行了....");//method 是？: public abstract void com.hspedu.spring.proxy2.Vehicle.run()//target_vehicle 是? Ship对象//args 是null//这里通过反射+动态绑定机制，就会执行到被代理对象的方法Object result = method.invoke(target_vehicle, args);System.out.println("交通工具停止运行了....");return result;}};/*public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)1. Proxy.newProxyInstance() 可以返回一个代理对象2. ClassLoader loader: 类的加载器.3. Class<?>[] interfaces 就是将来要代理的对象的接口信息4. InvocationHandler h 调用处理器/对象 有一个非常重要的方法invoke*/Vehicle proxy =(Vehicle)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);return proxy;}
}Test类
@Testpublic void proxyRun() {//创建VehicleProxyProvider对象, 并且我们传入的要代理的对象VehicleProxyProvider vehicleProxyProvider =new VehicleProxyProvider(new Car());//获取代理对象, 该对象可以代理执行方法//proxy的编译类型是 Vehicle, 运行类型是 class com.sun.proxy.$Proxy9Vehicle proxy = vehicleProxyProvider.getProxy();//当执行run方法时，会执行到 代理对象的invokeproxy.run();String result = proxy.fly(10000);System.out.println("result=" + result);}getProxy()的缺点
硬编码，功能不强，希望以方法的形式来执行一段业务
写成方法，耦合度高
//在目标对象执行前执行public void before(Method method, Object[] args) {System.out.println("before-方法执行前-日志-方法名-" + method.getName() + "-参数 "+ Arrays.asList(args)); //这里从AOP看，就是一个横切关注点-前置通知}//在目标对象执行后执行public void after(Method method, Object result) {System.out.println("after-方法执行正常结束-日志-方法名-" + method.getName() + "-结果result= "+ result);//从AOP看, 也是一个横切关注点-返回通知}进行解耦，写成AOP类，复用性差，不灵活，硬编码
public class HspAOP {public static void before(Method method, Object[] args) {}public static void after(Method method, Object result) {}
}AOP
面向切面编程
快速入门
环绕通知可以将四个通知合并管理
public interface SmartAnimalable {//求和float getSum(float i, float j);//求差float getSub(float i, float j);
}@Component //使用@Component 当spring容器启动时，将 SmartDog注入到容器
public class SmartDog implements SmartAnimalable {@Overridepublic float getSum(float i, float j) {float result = i + j;System.out.println("方法内部打印result = " + result);return result;}@Overridepublic float getSub(float i, float j) {float result = i - j;System.out.println("方法内部打印result = " + result);return result;}
}切面类
- @Before(value = "") 表示前置通知
value = "execution(public float spring.aop.aspectj.SmartDog.getSum(float, float)
指定切入到哪个类的哪个方法 形式是: 访问修饰符 返回类型 全类名.方法名(形参列表)- showBeginLog方法可以理解成就是一个切入方法
- JoinPoint joinPoint 在底层执行时，由AspectJ切面框架， 会给该切入方法传入 joinPoint对象，通过该方法，程序员可以获取到 相关信息
@Aspect //表示是一个切面类
@Component //会注入SmartAnimalAspect到容器
public class SmartAnimalAspect {@Before(value = "execution(public float spring.aspectj.SmartDog.getSum(float, float))")public void showBeginLog(JoinPoint joinPoint) {//通过连接点对象joinPoint 可以获取方法签名//invoke(Object proxy, Method method, Object[] args)整合到joinPointSignature signature = joinPoint.getSignature();System.out.println(signature.getName() + "-参数 "+ Arrays.asList(joinPoint.getArgs()));}
}XML开启AOP功能
<context:component-scanbase-package="com.hspedu.spring.aop.aspectj"/><!-- 开启基于注解的AOP功能 --><aop:aspectj-autoproxy/>如果不开启，.getClass()不会得到代理对象，只会得到当前运行的对象(相当于new)
Test类
@Testpublic void smartDogTestByProxy() {ApplicationContext ioc =new ClassPathXmlApplicationContext("beans08.xml");//需要通过接口类型来获取到注入的SmartDog对象-就是代理对象SmartAnimalable smartAnimalable =ioc.getBean(SmartAnimalable.class);//SmartAnimalable smartAnimalable =// (SmartAnimalable)ioc.getBean("smartDog");smartAnimalable.getSum(10, 2);}以前是new一个对象，获得这个类的的代理对象
动态代理返回的对象是个代理对象，强转成接口的形式返回
Animal proxy =
(Animal)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
return proxy;
（xml中开启AOP）现在通过接口类型获取的对象就是这个类的代理对象
细节
按接口来获取，多个类实现了接口会报错
UsbInterface interface = ioc.getBean(UsbInterface.class);interface是代理对象，获取Phone类的代理对象，getBean()就相当于之前的getPorxy()
UsbInterface interface = (UsbInterface)ioc.getBean(Phone.class);
UsbInterface interface = (UsbInterface)ioc.getBean("phone");
切入表达式
重用
//定义一个切入点, 在后面使用时可以直接引用, 提高了复用性@Pointcut(value = "execution(public float spring.aspectj.SmartDog.getSum(float, float)))")public void myPointCut() {}@Before(value = "myPointCut()")public void showBeginLog(JoinPoint joinPoint) {}@AfterReturning(value = "myPointCut()", returning = "res")public void showSuccessEndLog(JoinPoint joinPoint, Object res) {}@AfterThrowing(value = "myPointCut()", throwing = "throwable")public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {}两种动态代理
jdk的Proxy
面向接口，只能增强实现类中接口中存在的方法
得到的对象是JDK代理对象的实例
生成的代理对象只能转换成接口不能转换成被代理类
Spring的CGlib
面向父类，可以增强父类的所有方法
得到的对象是被代理对象的子类
JoinPoint常用方法
返回通知中获取结果
在@AfterReturning 增加属性 , 比如 returning = "res"，同时在切入方法增加 Object res
注意: returning = "res" 和 Object res 的 res名字一致
异常通知中获取异常
环绕通知
@Aspect
@Component
public class SmartAnimalAspect {//演示环绕通知的使用-了解//1. @Around: 表示这是一个环绕通知[完成其它四个通知的功能]//2. value = "execution(public float com.hspedu.spring.aop.aspectj.SmartDog.getSum(float, float)) 切入点表达式//3. doAround 表示要切入的方法 - 调用结构 try-catch-finally@Around(value = "execution(public float com.hspedu.spring.aop.aspectj.SmartDog.getSum(float, float))")public Object doAround(ProceedingJoinPoint joinPoint) {Object result = null;String methodName = joinPoint.getSignature().getName();try {//1.相当于前置通知完成的事情Object[] args = joinPoint.getArgs();List<Object> argList = Arrays.asList(args);System.out.println("AOP环绕通知[-前置通知]" + methodName + "方法开始了--参数有：" + argList);//在环绕通知中一定要调用joinPoint.proceed()来执行目标方法result = joinPoint.proceed();//2.相当于返回通知完成的事情System.out.println("AOP环绕通知[-返回通知]" + methodName + "方法结束了--结果是：" + result);} catch (Throwable throwable) {//3.相当于异常通知完成的事情System.out.println("AOP环绕通知[-异常通知]" + methodName + "方法抛异常了--异常对象：" + throwable);} finally {//4.相当于最终通知完成的事情System.out.println("AOP环绕通知[-后置通知]" + methodName + "方法最终结束了...");}return result;}
}切面优先级
如果同一个方法，有多个切面在同一个切入点切入，优先级如何控制
@order(value = n) 来控制，n 越小，优先级越高
前置通知通过@order来判断顺序
基于XML配置AOP
public interface SmartAnimalable {float getSum(float i, float j);float getSub(float i, float j);
}public class SmartDog implements SmartAnimalable {@Overridepublic float getSum(float i, float j) {return result;}@Overridepublic float getSub(float i, float j) {return result;}
}切面类将注解全部去掉
public class SmartAnimalAspect {public void showBeginLog(JoinPoint joinPoint) {}public void showSuccessEndLog(JoinPoint joinPoint, Object res) {}public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {}public void showFinallyEndLog(JoinPoint joinPoint) {}
}测试类
@Testpublic void testAspectByXML() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans09.xml");SmartAnimalable smartAnimalable =ioc.getBean(SmartAnimalable.class);smartAnimalable.getSum(10, 2);}<?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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"><!--使用XML配置，完成AOP编程--><!--配置一个切面类对象-bean--><bean class="com.hspedu.spring.aop.xml.SmartAnimalAspect" id="smartAnimalAspect"/><!--配置一个SmartDog对象-bean--><bean class="com.hspedu.spring.aop.xml.SmartDog" id="smartDog"/><!--配置切面类, 细节一定要引入 xmlns:aop--><aop:config><!--配置切入点--><aop:pointcut id="myPointCut" expression="execution(public float com.hspedu.spring.aop.xml.SmartDog.getSum(float, float)))"/><!--配置切面的前置，返回, 异常, 最终通知--><aop:aspect ref="smartAnimalAspect" order="10"><!--配置前置通知--><aop:before method="showBeginLog" pointcut-ref="myPointCut"/><!--返回通知--><aop:after-returning method="showSuccessEndLog" pointcut-ref="myPointCut" returning="res"/><!--异常通知--><aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="throwable"/><!--最终通知--><aop:after method="showFinallyEndLog" pointcut-ref="myPointCut"/><!--配置环绕通知--><!--<aop:around method=""/>--></aop:aspect></aop:config>
</beans>
