Spring

1.Spring组成

Spring框架包含很多模块，下边列举了比较常用的模块。

1）核心容器：Spring的基础，提供了依赖注入功能，通过依赖反转将程序配置机及其依赖关系和程序代码分开。

2）Spring AOP:提供切面能力，可以在代码中插入公共代码，无耦合，可以大幅减少代码量并且便于管理，让业务不关注日志，事务等公共能力。

3)Spring Context:通过配置文件，向Spring框架添加上下文能力，国际化，多语言等。

4）Spring DAO:提供的简单的JDBC应用

5）Spring ORM:提供和不同ORM框架集成的支持

6 )Spring MVC：Spring也提供了MVC的实现。

2.注入方式

接口注入:

set注入:

package com.bless.springdemo.action;
public class SpringAction {
//注入对象springDao
private SpringDao springDao;
//一定要写被注入对象的set方法
public void setSpringDao(SpringDao springDao) {
this.springDao = springDao;
}

public void ok(){
springDao.ok();
}
}

<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<!--(1)依赖注入,配置当前类中相应的属性-->
<property name="springDao" ref="springDao"></property>
</bean>
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

构造器注入：

public class SpringAction {
//注入对象springDao
private SpringDao springDao;
private User user;

public SpringAction(SpringDao springDao,User user){
this.springDao = springDao;
this.user = user;
System.out.println("构造方法调用springDao和user");
}

public void save(){
user.setName("卡卡");
springDao.save(user);
}
}
<!--配置bean,配置后该类由spring管理-->
<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->
<constructor-arg ref="springDao"></constructor-arg>
<constructor-arg ref="user"></constructor-arg>
</bean>
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>
<bean name="user" class="com.bless.springdemo.vo.User"></bean>

 

xml配置:

http://blog.csdn.net/zzjjiandan/article/details/22922847/ 

注释配置

http://blog.csdn.net/xyh820/article/details/7303330/

 

DI原理:

 http://blog.csdn.net/it_man/article/details/4402245

反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。

 

Bean

bean的使用:http://www.cnblogs.com/xiaoxi/p/5850095.html

<bean
    id="beanId"（1）
    name="beanName"（2）
    class="beanClass"（3）
    parent="parentBean"（4）
    abstract="true | false"（5）
    singleton="true | false"（6）
    lazy-init="true | false | default"（7）
    autowire="no | byName | byType | constructor | autodetect | default"（8）
    dependency-check = "none | objects | simple | all | default"（9）
    depends-on="dependsOnBean"（10）
    init-method="method"（11）
    destroy-method="method"（12）
    factory-method="method"（13）
    factory-bean="bean">（14）
</bean>

（1）id: Bean 的唯一标识名。它必须是合法的 XML ID，在整个 XML 文档中唯一。

（2）name: 用来为 id 创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。

（3）class: 用来定义类的全限定名（包名＋类名）。只有子类 Bean 不用定义该属性。

（4）parent: 子类 Bean 定义它所引用它的父类 Bean。这时前面的 class 属性失效。子类 Bean 会继承父类 Bean 的所有属性，子类 Bean 也可以覆盖父类 Bean 的属性。注意：子类 Bean 和父类 Bean 是同一个 Java 类。

（5）abstract（默认为”false”）：用来定义 Bean 是否为抽象 Bean。它表示这个 Bean 将不会被实例化，一般用于父类 Bean，因为父类 Bean 主要是供子类 Bean 继承使用。

（6）singleton（默认为“true”）：定义 Bean 是否是 Singleton（单例）。如果设为“true”,则在 BeanFactory 作用范围内，只维护此 Bean 的一个实例。如果设为“flase”，Bean将是 Prototype（原型）状态，BeanFactory 将为每次 Bean 请求创建一个新的 Bean 实例。

（7）lazy-init（默认为“default”）：用来定义这个 Bean 是否实现懒初始化。如果为“true”，它将在 BeanFactory 启动时初始化所有的 Singleton Bean。反之，如果为“false”,它只在 Bean 请求时才开始创建 Singleton Bean。

（8）autowire（自动装配，默认为"default"）：它定义了 Bean 的自动装载方式。
"no"：不使用自动装配功能。
"byName"：通过 Bean 的属性名实现自动装配。
"byType"：通过 Bean 的类型实现自动装配。
"constructor"：类似于 byType，但它是用于构造函数的参数的自动组装。
"autodetect"：通过 Bean 类的反省机制（introspection）决定是使用“constructor”还是使用“byType”。

（9）dependency-check（依赖检查，默认为“default”）：它用来确保 Bean 组件通过 JavaBean 描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。
none：不进行依赖检查。
objects：只做对象间依赖的检查。
simple：只做原始类型和 String 类型依赖的检查
all：对所有类型的依赖进行检查。它包括了前面的 objects 和 simple。

（10）depends-on（依赖对象）：这个 Bean 在初始化时依赖的对象，这个对象会在这个 Bean 初始化之前创建。

（11）init-method:用来定义 Bean 的初始化方法，它会在 Bean 组装之后调用。它必须是一个无参数的方法。

（12）destroy-method：用来定义 Bean 的销毁方法，它在 BeanFactory 关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singleton Bean。

（13）factory-method：定义创建该 Bean 对象的工厂方法。它用于下面的"factory-bean"，表示这个 Bean 是通过工厂方法创建。此时，"class"属性失效。

（14）factory-bean:定义创建该 Bean 对象的工厂类。如果使用了"factory-bean"则"class"属性失效。

1.bean类型

Spring容器最初提供了两种bean的scope类型：singleton和prototype,但发布2.0以后，又引入了另外三种scope类型：request、session和global session,这三种只能在web 应用中才可以使用。

singleton: Spring 容器只会创建该bean定义的唯一实例，这个实例会被保存到缓存中，并且对该bean的所有后续请求和引用都将返回该缓存中的对象实例，一般情况下，无状态的bean使用该scope。

prototype:每次对该bean的请求都会创建一个新的实例，一般情况下，有状态的bean使用该scope。

request：每次http请求将会有各自的bean实例，类似于prototype。

session：在一个http session中，一个bean定义对应一个bean实例。

global session：在一个全局的http session中，一个bean定义对应一个bean实例。典型情况下，仅在使用portlet context的时候有效。

2.bean初始化

配置init-method属性

实现InitializingBean接口

3.bean调用

1.从ApplicationContex应用上下文容器中获取bean和从bean工厂容器中获取bean

从ApplicationContext中取bean

ApplicationContextac=new ClassPathXmlApplicationContext("com/hsp/ioc/beans.xml");

当我们去实例化beans.xml,该文件中配置的bean被实例(该bean scope是singleton)从bean中取出 ，如果我们使用beanfactory去获取bean，当你只是实例化该容器， 那么容器的bean不被实例化,只有当你去使用getBean某个bean时，才会实时的创建.

 BeanFactory  factory = new XmlBeanFactory(newClassPathResource("com/hsp/ioc/beans.xml"));

factory.getBean("student");

2.结论

a.如果使用ApplicationContext，则配置的bean如果是 singlton不管你用不用，都被实例化.(好处就是可以预先加载,缺点就是耗内存)

b.如果是BeanFactory ,则当你获取beanfacotry时候，配置的bean不会被马上实例化，当你使用的时候，才被实例(好处节约内存,缺点就是速度)

c.规定: 一般没有特殊要求，应当使用ApplicatioContext完成(90%)

 

Spring AOP

http://blog.csdn.net/udbnny/article/details/5870076

AOP的四种方式:

1.基于java代理的aop（需要实现接口，配置代理类）

2.基于java类的aop（不需要配置代理类）

3.基于Aspect注解的aop（注解）

4.基于注入切面的aop（xml）

aop方式：http://blog.csdn.net/u010419967/article/details/52195853

http://blog.csdn.net/u010987379/article/details/52152925

http://www.cnblogs.com/nsw2018/p/5881723.html

Spring事务处理

 

还需要自己下载第三方依赖包：

aspectjrt.jar，aspectjweaver.jar(最新发布版是1.6.2，eclipse网站有下载)

以及aopalliance.jar（最新发布版是1.0，http://sourceforge.net/projects/aopalliance/有下载）

引入以上jar包之后，就可以通过@Aspect等注解方式进行AOP编程了；

 

execution语法

execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)  除了返回类型模式、方法名模式和参数模式外，其它项都是可选的。

* com.dcits..*Service*.*(..)    //dcits包及子包下的包含Service类的方法

execution(* com..*.*Dao.find*(..)) com包及其子包下以Dao结尾的类，方法以find为前缀。

http://blog.csdn.net/abcd898989/article/details/50809321

 

spring框架：

http://blog.csdn.net/u012291108/article/details/51669900

posted on 2017-07-20 16:11  小付瓜  阅读(86)  评论(0)    收藏  举报