Spring框架---day06

Spring框架—day06

spring的接口注入

Spring的接口注入：java当中的接口主要是来进行多继承。java是单继承， 当我们在使用其他的一些方法的时候，把这些方法写到接口中，然后多现实接口。类可以继承我们的类，但是是单继承； 当你进行我们的多个的时候，做接口。接口直接可以多个接口，但接口不能实现接口。

在你进行项目的过程中， 接口就相当是一个模板 。在Spring中，如果要实现业务和具体实现的分离（就是在写程序的时候，crud的时候首先先进行一个接口的编程）就是规定你的当前项目业务中的方法，这些方法就写在我们的接口中，采用面向接口的编程可以省去大量代码。当然在开发大型的java项目中，分层是不可避免的，分层可以使框架的结构清晰，容易理解，并且提高开发的效率。层和层之间的解耦合，也就是我们在我们的每一层中去调用下一层的操作的时候， 只需要注入他的上层就可以。

根据我们的分层进行的操作： 就是我们的接口和注解的使用。

Spring的一个重点是要求业务和实现分离，比如我们模拟狗叫声是一个业务，要实现此业务，我们只需要在业务层调用狗类（狗类才去具体的实现）。那要是后面要模拟老虎叫声的业务的时候，就是要在业务层调用老虎类。这样要是一个动物园，那就是有好多的调用动物类。这样代码量大。

例子:

使用spring的接口的方式来来进行我们的这个大小写转换

1.抽取出来一个接口,这个接口中是一些方法,这些方法适合大写转换和小写转换。

2.创建类, 让大写转小写,小写转大写都去实现这个接口。

3.在测试类中进行测试。

public interface StrChange {
	void change() throws Exception;
}

public class LowStr implements StrChange{
	private String str;

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	public void change() throws Exception {
		System.out.println(str.toLowerCase());
		
	}
}

public class UpStr implements StrChange{
	private String str;
	
	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	public void change() throws Exception {
		System.out.println(str.toUpperCase());
		
	}
}

public static void main(String[] args) throws Exception {
		ApplicationContext app=new ClassPathXmlApplicationContext("bean01.xml");
		UpStr upStr=app.getBean("upStr",UpStr.class);
		LowStr lowStr=app.getBean("lowStr",LowStr.class);
		upStr.change();
		lowStr.change();
	}

<bean id="upStr" class="com.zll.interface01.UpStr">
	   <property name="str" value="ASDqwefg"></property>
	   </bean>
	   <bean id="lowStr" class="com.zll.interface01.LowStr">
	   <property name="str" value="ASDqwefg"></property>
	   </bean>

spring常用的注解

@Controller（代表这个这个类是一个控制层的类，web开发的时候）组合注解（组合了@Component注解），应用在MVC层（控制层）,DispatcherServlet会自动扫描注解了此注解的类，然后将web请求映射到注解了@RequestMapping的方法上。

@Service组合注解（组合了@Component注解），应用在service层（业务逻辑层）

@Reponsitory组合注解（组合了@Component注解），应用在dao层（数据访问层）

@Component表示一个带注释的类是一个“组件”，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选对象。同时@Component还是一个元注解。

@Autowired 自动装配，他默认使用byType的方式来进行装配bean

@Qualifier是和Autowired一起， 当我们要通过name来装配的时候。

@Resource 自动装配，使用默认使用的byName来进行装配

@Inject根据类型进行自动装配的，如果需要按名称进行装配，则需要配合@Named；

@Configuration 声明当前类是一个配置类（相当于一个Spring配置的xml文件）

@ComponentScan自动扫描指定包下所有使用@Service,@Component,@Controller,@Repository的类并注册

@Bean注解在方法上，声明当前方法的返回值为一个Bean。返回的Bean对应的类中可以定义init()方法和destroy()方法，然后在@Bean(initMethod=”init”,destroyMethod=”destroy”)定义，在构造之后执行init，在销毁之前执行destroy。

@PostConstruct标注在方法上，该方法在构造函数执行完成之后执行。

@PreDestroy标注在方法上，该方法在对象销毁之前执行。

代理模式

什么是代理模式呢？我很忙，忙的没空理你，那你要找我，就先找我的代理人，但代理人总要知道被代理人能做哪些事情不能做哪些事情吧，那就是两个人具备同一个接口，代理人虽然不能干活，但是被代理的人能干活呀。 类似于明星与经纪人。

代理模式，其实就是我们在写代码的时候，可以抽象出来一个代理，以后我们想去用一个类的时候，我们不直接使用，而是找代理来进行处理。

我们有一个代理类， 做我们被代理对象， 和代理的对象之间一个桥梁。

代理分为我们的两种代理（1.静态代理：就是这个代理他只会给一个做代理。 动态代理：他可以根据具体的情况，当你传入过来一个的时候我们就可以给他做代理）

静态代理:每一个城市中的代理商（汽车代理 他只会给我们的一种做代理）

动态代理：（啥都可以代理：根据你的传过来的内容做我们的代理，黄牛）

代理模式一般涉及到的角色有：

抽象角色：声明真实对象和代理对象的共同接口。
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

代理：他可以完全作为你的代理去做事情；

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

例如:

王婆：作为我们的代理类

潘金莲： 被代理的对象

西门庆： 需要进行调用代理,去和代理对象一起做事情的

西门庆----通过 ----王婆---- 和潘金莲

//一个接口，提供代理对象和真实对象都可以完成的接口
public interface KindWomen {
	public void makeEyesWithMan();//可以做的事情
	public void happyWithMan();
}

//代理对象，也要实现接口
public class WangPo implements KindWomen{
	private KindWomen kindWomen;
	public WangPo() {//默认上来之后它给潘金莲做代理
		this.kindWomen=new PanJinLian();
	}
	public WangPo(KindWomen kindWomen) {//也可以给其他人做代理
		this.kindWomen=kindWomen;
	}
	
	public KindWomen getKindWomen() {
		return kindWomen;
	}
	public void setKindWomen(KindWomen kindWomen) {
		this.kindWomen = kindWomen;
	}
	public void makeEyesWithMan() {
		this.kindWomen.makeEyesWithMan();//王婆只是代理，具体的事情还是真实对象干
		
	}

	public void happyWithMan() {//王婆只是代理，具体的事情还是真实对象干
		this.kindWomen.happyWithMan();
		
	}

}

public class PanJinLian implements KindWomen{

	public void makeEyesWithMan() {
		System.out.println("潘金莲可以抛媚眼");
		
	}

	public void happyWithMan() {
		System.out.println("潘金莲可以******");
		
	}
}

public class WuSong implements KindWomen{
	
	public void makeEyesWithMan() {
		System.out.println("我是武松，我让王婆做代理，抛媚眼");
	}

	public void happyWithMan() {
		System.out.println("我是武松，我让王婆做代理，我不想干铺头了");
		
	}

}

public class XiMenQing {
	public static void main(String[] args) {
		WangPo wangPo=new WangPo();
		wangPo.makeEyesWithMan();
		wangPo.happyWithMan();
		WangPo wangPo2=new WangPo(new WuSong());
		wangPo2.makeEyesWithMan();
		wangPo2.happyWithMan();
	}
}

spring中的aop

Spring Aop（Aspect Oriented Programming）面向切面编程。是现在比较常用的技术，他在1990年的时候就出现 ，当时面向对象已经趋于成熟，在开发中有些局限性，所以提出了aop面向切面编程。

Aop就是在不增加代码的情况下，还添加了新的功能。日志，事务，等等。就相当我们在我们的切面上进行调用我们的新的一些方法。

SpringAOP是继spring ioc的 spring 的一大特点。他也是spring框架的核心内容。Aop是一种思想。只要符合aop思想的技术就都是aop的实现（生活当中保安就相当是我们的aop切面；）。Aop是建立在Java的动态代理机制之上。

Spring ioc底层实现原理：使用的反射机制， 注解的底层实现也是使用反射机制；

Spring aop：他使用的是代理机制（动态代理）

Spring AOP的实现是基于Java的代理机制，从JDK1.3开始就支持代理功能，但是性能成为一个很大问题，为了解决JDK代理性能问题，出现了CGLIB代理机制（继承你的代理类）。它可以生成字节码，所以它的性能会高于JDK代理。Spring支持这两种代理方式。但是，随着JVM(Java虚拟机)的性能的不断提高，这两种代理性能的差距会越来越小。

在spring中很多的代理机制都使用的是我们的cglib（代码库）

Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。

很多的框架中的代理使用的cglib代理来实现

Java的原生的动态代理的性能比cglib要弱好多

CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy何BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。

AOP适合于那些具有横切（切面）逻辑的应用：如性能监测（druid），访问控制（单点登录），事务管理(增删改 都要对你的数据库操作)、缓存（当你的业务走到这个切面后，写缓存）、对象池管理以及日志记录（tomcat写日志）。AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中（以前的我们在各个方法中去调用的方法,比如写日志方法,我们可以抽取出来放在切面上, 只要你的方法进入到我们的切面就会调用方法）。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强,而动态代理则在运行时借助于 JDK 动态代理、（运行时增强）CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

Cglib在spring当中很多地方都使用他来做代理,主要使用的动态代理（运行时增强）

代理对象的方法 = 增强处理 + 被代理对象的方法

Spring AOP 则采用运行时（动态代理cglip）生成 AOP 代理类，因此无需使用特定编译器进行处理。由于 Spring AOP 需要在每次运行时生成 AOP 代理，因此性能略差一些。

AOP使用场景（框架本身的用的很多）

AOP用来封装横切关注点（切面），具体可以在下面的场景中使用

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading 懒加载

Debugging 调试

logging, tracing, profiling and monitoring 记录跟踪 优化 校准

Performance optimization 性能优化

Persistence 持久化

Resource pooling 资源池

Synchronization 同步

Transactions 事务

Spring在项目开发的过程中： 日志管理,缓存操作,事务管理,性能管理,使用的频率比较大。

地方都使用他来做代理,主要使用的动态代理（运行时增强）

代理对象的方法 = 增强处理 + 被代理对象的方法

Spring AOP 则采用运行时（动态代理cglip）生成 AOP 代理类，因此无需使用特定编译器进行处理。由于 Spring AOP 需要在每次运行时生成 AOP 代理，因此性能略差一些。

AOP使用场景（框架本身的用的很多）

AOP用来封装横切关注点（切面），具体可以在下面的场景中使用

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading 懒加载

Debugging 调试

logging, tracing, profiling and monitoring 记录跟踪 优化 校准

Performance optimization 性能优化

Persistence 持久化

Resource pooling 资源池

Synchronization 同步

Transactions 事务

Spring在项目开发的过程中： 日志管理,缓存操作,事务管理,性能管理,使用的频率比较大。