Spring2~~~

大连密封材料 · 6 天前

注解配置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-filter
1. 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容器中的对象和装配的对象哈希值不肯定一样

<context:component-scan
base-package="com.hspedu.spring.component"/>
<bean class="com.hspedu.spring.component.UserService" id="userService200"/>
<bean class="com.hspedu.spring.component.UserService" id="userService300"/>

复制代码

@Controller
public class UserAction {
@Autowired
private 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{
@Override
public void run() {
//System.out.println("交通工具开始运行了....");
System.out.println("小汽车在路上 running....");
//System.out.println("交通工具停止运行了....");
}
@Override
public 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
*/
@Override
public 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类

@Test
public void proxyRun() {
//创建VehicleProxyProvider对象, 并且我们传入的要代理的对象
VehicleProxyProvider vehicleProxyProvider =
new VehicleProxyProvider(new Car());
//获取代理对象, 该对象可以代理执行方法
//proxy的编译类型是 Vehicle, 运行类型是 class com.sun.proxy.$Proxy9
Vehicle proxy = vehicleProxyProvider.getProxy();
//当执行run方法时，会执行到代理对象的invoke
proxy.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 {
@Override
public float getSum(float i, float j) {
float result = i + j;
System.out.println("方法内部打印result = " + result);
return result;
}
@Override
public 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)整合到joinPoint
Signature signature = joinPoint.getSignature();
System.out.println(signature.getName() + "-参数 "
+ Arrays.asList(joinPoint.getArgs()));
}
}

复制代码

XML开启AOP功能

<context:component-scan
base-package="com.hspedu.spring.aop.aspectj"/>
<aop:aspectj-autoproxy/>

复制代码

假如不开启，.getClass()不会得到署理对象，只会得到当前运行的对象(相当于new)
Test类

@Test
public 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 {
@Override
public float getSum(float i, float j) {return result;}
@Override
public 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) {}
}

复制代码

测试类

@Test
public 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">
<bean class="com.hspedu.spring.aop.xml.SmartAnimalAspect" id="smartAnimalAspect"/>
<bean class="com.hspedu.spring.aop.xml.SmartDog" id="smartDog"/>
<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:aspect>
</aop:config>
</beans>

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

Spring2~~~

0 个回复

快速回复

楼主热帖

标签云