关于spring

关于spring

Spring的三大核心技术：IOC（控制反转）， DI（依赖注入），AOP（面向切面编程，是面向对象的补充）

1. IOC(自己的理解)
   启动的时候通过xml或者注解扫描，把配置好的类通过反射实例化，然后不用用户手动创建对象，把创建对象的控制权交给spring容器，效果就像是控制权反转了一样，从用户到spring容器。
2. DI
   其实这个就是参数版本的IOC我觉得这两个应该算一个，所有配置的参数都在容器里传递。
3. AOP
   运用动态代理的方式，在内存临时生成一个对象，在切点处进行增强操作然后返回原对象。

优点
（1） 非侵入式设计
（2） 方便解耦 简化开发
（3） 支持AOP 面向切面
（4） 支持声明式事务处理
（5） 方便程序测试
（6） 方便集成各种优秀框架
（7） 降低JAVA EE API的使用难度

入门程序
步骤：

1. 创建web项目

2. 导包 四个核心包一个依赖包

3. 配置文件

4. 测试

Public class UserService{}
Public class UserServlet{
UserFactory.getSerice();
}
<bean id=”userService” class=””>
Public static UserService getService(){
String classValue=”class属性值”		
Class class=Class.forName(classValue);  利用反射创建类对象
userServicee service=calss.newInstance();
return service;
}

Spring三大核心技术 IOC DI AOP ；最基础的概念是bean所有操作都是针对Object ， 在String中的所有文件都可以认为是注册和未注册的bean ， String中所有操作都是针对bean的操作 ， 三大思想的操作对象， 也都是bean！！

IOC（控制反转）:
首先理解什么是控制不反转！

Public inter IPrint	{
String printObject();	
}			//创建一个接口
Public class UserBean implement IPrint{
Public String printObject(){
System.out.print(“打印对象UserBean：”);
Return “abc”
}
}	//第一个实现类
Public class MyBean implement IPrint{
			Public String printObject(){
					System.out.print(“打印对象MyBean：”);
								}
}	//第二个实现类

打印第一个实现类，客户端代码如下：

IPrint print=new UserBean();		实例化对象
Print.printObject();	

创建实例化对象 然后实现方法
然后打印第二个实现类 这时候就需要修改代码 对于正经的系统来说 修改代码不符合开闭原则 又比较麻烦的事 所以就想能不能用配置文件来代替代码的修改 这时候就需要spring的控制反转 对继承了接口IPrint的具体实现类的具体对象的创建 不依赖于调用它的客户端代码 而将控制权交给Spring 这就是控制反转
配置xml文件：

<?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="userBean" class="testSpring.business.bean.UserBean">
    </bean>



</beans>

测试代码：

ApplicationContext ctx=new ClassPathXmlApplication(“applicationContext.xml”);
IPrint bean=(IPrint)ctx.getBean(“userBean”);
bean.Object();

如果想要打印另一个实现类 只要修改配置文件

<bean id="MyBean" class="testSpring.business.bean.MyBean">

DI（依赖注入）：
…谁依赖谁 什么注入 向谁注入

Public class UserBean printObiect(){
	Public String printObject(){
			System.out.print(“打印对象UserBean:”);
			Return “abc”;
							}
}  //实现类
Publc class Print{
	Private IPint printBean;	//需要注入的对象 需要打印的bean
	Private String name;
	Public void print(){
		System.out.print(“注入的name：”+name);
		This.printBean.printObject();
}
	Public void setprintBean(IPint printBean){
		This.printBean=printBean;
			}
	Public void setname(String name){
		This.name=name;
			}
}
	普通的时用print类的客户端代码
	Print p=new Print();
	p.setPrintBean(new UserBean());
	print.print();
	依赖注入客户端代码
	Xml文件如下
	<?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="userBean" class="testSpring.business.bean.UserBean">
    </bean>
	<bean id=”printBean” class=”…..Print”>
		<property name=”printBean” ref=”userBean”/>
		<property name=”name” value=”haha”/>
	</bean>
</beans>
	客户端代码
ApplicationContext ac=new ClassPathXmlApplicationContext(“beans.xml”);
Print bean=ac.getBean(“printBean”);
Bean.print();

AOP（面向切面编程）
运用动态代理的方式，在内存临时生成一个对象，在切点处进行增强操作然后返回原对象。
连接点：类似于可以被增强的方法
切入点：可以被增强的连接点 实际被增强的方法 就是切入点
Advice：AOP框架在特定的切入点执行的增强处理 即在定义好的切入点处所即将要执行的程序代码 可以理解将其理解为切入类中俄方法
Target Object：代理对象
Proxy：将通知应用到目标对象之后 被动态创建的对象
Weaving：将切面代码插入到目标对象上 从而生成代理对象的过程

@org.aspectj.lang.annotation.Aspect
@Component("Aspect")
public class Aspect {
    @Pointcut("execution(* com.jiang.dao.*.*(..))")
    private void myPointCut(){}
    @Before("myPointCut()")
    public void beforeAdvice(JoinPoint joinPoint)
    {
        System.out.println("前置通知：模拟执行权限检查");
        System.out.println("被织入的增强处理的目标方法为："+joinPoint.getSignature().getName());
    }
    @AfterReturning("myPointCut()")
    public void afterReturningAdvice(JoinPoint joinPoint)
    {
        System.out.println("后置通知：模拟执行日志检查");
        System.out.println("被植入的增强处理的目标方法为："+joinPoint.getSignature().getName());
    }
    @Around("myPointCut()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕开启");
        Object obj;
        obj = proceedingJoinPoint.proceed();
        System.out.println("环绕结束");
        return obj;
    }
    @AfterThrowing(value = "myPointCut()",throwing = "e")
    public void afterThrowingAdvice(JoinPoint joinPoint ,Throwable e)
    {
        System.out.println("异常通知："+"出错了"+e.getMessage());
    }
    @After("myPointCut()")
    public  void  afterAdvice()
    {
        System.out.println("最终通知");
    }
}