Spring的理解以及注解配置Spring

Spring概念:是一个轻量级控制反转(IOC)和,面向切面(AOP)的容器.装什么像什么,什么都可以装,管理者是对象.运用于一

式的开发,不排斥任何框架.

SpringAOP:.将通知织入到被代理对象，返回代理对象的过程. 思想是面向切面, 横向重复,纵向提取

DI: 依赖注入,实现IOC的技术支持

SpringIOC:Inversion of Control 的缩写，多数书籍翻译成“控制反转”，还有些书籍翻译成为“控制反向”或者“控制倒置;

(也就是将创建对象的过程交给容器)

依赖注入 (DI) 和控制反转 (IOC) 是从不同的角度的描述的同一件事情，就是指通过引入 IOC 容器，利用依赖关系注入 的方式，实现对象之间的解耦

bean的详解:

bean:描述被管理的对象

name:获取对象的时候通过名称获取,支持特殊字符

class:包名到类名的指向

id:与name一样,不可重复,不支持特殊字符

scope="singleton":单例;默认是单例,常用也是单例

scope="prototype":多例

request:对象与 request 生命周期一致(了解)

session:对象与 session 生命周期一致 在web中使用(了解)

案例:

<bean name="user1" class="com.offcn.bean.User" scope= "singleton"></bean>

生命周期:

bean 的声明周期 : 对象从创建到销毁执行过程

init-method="" 对象初始化执行的方法

destory-method="destory" 对象销毁时执行的方法

<bean name="user1" class="com.offcn.bean.user" scope= "singleton" init-method="init" destory-method= "destory"></bean>

初始化执行的方法及对象销毁时执行的方法:

public void init(){ System.out.println("初始化执行的方法"); } public void destory(){ System.out.pringln("对象销毁时执行的方法"); }

创建容器:

注:对象生命周期销毁的方法,在容器销毁时执行,AppliactionContext容器接口没有销毁方法,所以直接用ClassPathXmlApplicationContext直接创建容器.

ApplicationContext与BeanFactory的区别:

BeanFactory: 早起容器取对象时即getBean,创建对象.(为了节省内存)

ApplicationContext:容器创建时创建对象

Spring创建对象的方式:

1.空参构造:

<bean name="user1" class="com.offcn.bean.User"></bean>

2.静态工厂(了解):

静态方法的创建: 工厂类名.静态方法名

factory-method: 工厂方法

<bean name="user1" class="com.offcn.bean.userFactory" factory-method="createUser1"></bean>

静态工厂的方法:

public static createUser1(){ System.out.printli("静态工厂的方法执行"); return new user(); }

3.实例工厂(了解):

实例方法的创建: 工厂对象.方法名

factory-method: 工厂方法

factory-bean:引用的工厂

引用工厂: User user = factory.createUser1();

<bean name= "user" factory-bean="factroy" factory-method="createUser2"></bean>

实例工厂的配置:Factory factory = new Factory();

实例化工厂方法:

public User createUser2(){ system.out.println("实例化的方法执行"); return new User(); }

依赖注入:

set方法注入(重要):(前提是 set 注入之前该对象提供 setter 方法)

<bean name="user1" class="com.offcn.bean.User"> //值类型 <property name="id" value="102"></property> <property name="name" value="张三"></property> //对象型 <property name="name" ref="c1"></property>   </bean> <bean name="c1" class="com.offcn.bean.Car"> <property name="pp" value="魅影"></property> <property name="color" value="黑色"></property>   </bean>

public class User (){ private int id; pricate String name; private Car car; }

构造方法注入:

constructor-arg:构造注入参数

name :构造方法中参数列表的参数名

value:注入的参数值

type:注入的参数类型

index:参数列表中的参数下标

<bean name="user1" class="com.offcn.bean.User"> <constructor-arg name="id" name="1" type="int" index="0"> </constructor-arg> <constructor-arg name="name" name="zhang" type="int" index="1"> </constructor-arg> <constructor-arg name="car" hef="c1" index="2"> </constructor-arg>   </bean>

public User (int id, String name ,Car car){ supper(); this.id = d; this.name = name; this.car = car;   }

public User ( Car car , int id, String name){ supper(); this.id = id; this.name = name; System.out.println("hello');   }

p命名空间注入:

值类型注入: p: 属性名="值"

对象类型注入: p: 属性名-ref="bean:name"

<bean name="user1" class="com.offcn.bean.User" p:id="102" p:name ="liu" p:car-ref="c1"></bean>

SpEL（Spring Expression Language）注入

Spring表达式语言:

<bean name="c2" class="com.offcn.bean.Car">   <property name="pp" value="#{c1.pp}"></property> <property name="color" value="黑色"></property>   </bean>

复杂类型的注入:

数组类型(Array):

<bean name="type1" class="com.offcn.bean.collectionType"> 如果数组中只有一条数据则: <property name="arr" value="1"></property> 多条数据: <property name="arr"> <array> 值类型 <value>tom</value> <value>dad</value> <value>fsfsd</value> 对象类型 <ref bean ="c2"/> </array> </property> </bean>

list和map

<bean name="type1" class="com.offcn.bean.collectionType"> <property name="list"> <list> 值类型 <value>tom</value> <value>1ssss</value> <value>fsfeww</value> 对象类型 <ref bean ="c1"/> </list> </property> </bean>

<bean name="type1" class="com.offcn.bean.collectionType"> <property name="map"> <map> <entry key="1233" value="tom"></entry> <entry key="13" value="dad"></entry> <entry key="13" value-ref="c2"></entry> <entry key-ref="c1" value-ref="c2"></entry> </map> 注: key是map中的key </property> value是map中的value </bean> ref中的key和value是对象

properties注入:

<bean name="type1" class="com.offcn.bean.collectionType"> <property name="properties"> <props> <prop key = "url">www.ujiuye.com</prop> <prop key = "name">ujiuye</prop> <prop key = "name1">java</prop> </props> </property> </bean>

Spring 的模块配置:

<impord resource="com.offcn.bean.applicationContext.xml"/>

注解配置Spring:

步骤:

1.导包加命名空间:

2.在xml中添加扫描.开启注解配置

3. 在类中完成配置

常用的注解配置:

对象的配置

@omponent

@ervice

@Controller

@respository

属性的配置:(Scope)

@Scope(scopeName="prototype")

属性---值类型

属性:@Value ("值"),破坏了对象的封装性

set() :官方推荐使用这种方式

属性---引用类型

@Autowried: 自动装配

@Qulifier("name"): 指定名称,跟Autowried连用

@Resource("name="): 指定资源访问,单独使用

生命周期的方法:

@postConstruct: 初始化

PreDestory: 销毁

Spring整合Junit4测试:

@Runwith(SpringJunit4Runner.class)

@ContextConfiguration("classpath:applicationContext"):创建容器

SpringAOP:面向切面.

JDK动态代理: 必须使用接口

Cglib代理: 第三方代理技术.不需要使用接口

Spring:可以对任何对象进行代理(增强)

oop:面向对象 万物皆对象

名词解释:

JoinPoint( 连接点 ): 在目标对象中，所有可以增强的方法。 PointCut( 切入点 )：目标对象，已经增强的方法。   Advice( 通知 / 增强 )：增强的代码   Target( 目标对象 )：被代理对象   WeAVing( 织入 ): 将通知应用到切入点的过程 Proxy( 代理 )：是通知目标对象后创建的对象。从客户端的角度看，代理对象和目标 对象是一样的   Aspect( 切面 )：AOP 核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组 API 提供横切功能。   前置通知: 目标方法之前调用   后置通知: （如果出现异常不会调用） 在目标方法运行之后   环绕通知: 在目标方法之前和之后都调用   异常拦截通知: 如果出现异常，就会调用   后置通知: （无论是否出现异常都会调用） 在目标方法运行之后调用