Spring2.5(1)

最新推荐文章于 2021-12-23 17:21:32 发布

花开不合阳春暮

最新推荐文章于 2021-12-23 17:21:32 发布

阅读量203

点赞数

分类专栏： # Spring 文章标签： spring

本文链接：https://blog.csdn.net/wszcy199503/article/details/54861515

版权

Spring 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

Spring是什么？
Spring是开源的控制反转(IOC)和面向切面(AOP)的容器框架，它的主要目的是简化企业开发。
IOC 控制反转

public class personServiceBean{
private PersonDao personDao = new PersonDaoBean();
public void save(Person person){
personDao.save(person);
}
}

PersonDaoBean是在应用内部创建及维护的，所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就有应用转移到了外部容器，控制权的转移就是所谓的反转。
依赖注入(Dependency Injection)
当我们把依赖对象交给外部容器负责创建，那么PersonServiceBean 类可以改成如下：

public class PersonServiceBean {
    private PersonDao personDao ;
   //通过构造器参数，让容器把创建好的依赖对象注入进PersonServiceBean，当然也可以使用setter方法进行注入。
     publicPersonServiceBean(PersonDao personDao){
       this.personDao=personDao;
    }
     public void save(Person person){
          personDao.save(person);
    }
}

所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

为何要使用Spring
至少在我看来，在项目中引入spring立即可以带来下面的好处
.降低组件之间的耦合度,实现软件各层之间的解耦。
controller --<service --< dao
.可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
.容器提供单例模式支持，开发人员不再需要自己编写实现代码。
.容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
.容器提供的众多辅作类，使用这些类能够加快应用的开发，如： JdbcTemplate、HibernateTemplate。
.Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。
使用Spring的好处
当使用spring时，我们可以使用容器提供的众多服务

如果使用Spring, 我们就不再需要手工控制事务
Hibernate的事务操作:

 public void save(){
Session session = sessionFactory.getCurrentSession();
                 //session.beginTransaction(); 
Info info = new Info("传智播客");
info.setContent("国内实力最强的java培训机构");
session.save(info );
//session.getTransaction().commit();
     }

JDBC的事务操作:

Connection conn = null;
     try{
     .......
    //conn.setAutoCommit(false);
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("update person wherename='叶天'");
    //conn.commit();
    .....
     }//catch (Exception e) {
      //conn.rollback();  }finally{conn.close();}
另外，如果使用spring, 我们也不需要处理复杂的事务传播行为
public void payment(){
      Bean1.update();//更新金额
      Bean2.save();//记录操作日志
}

如果我们不使用Spring，针对下面这两种业务需求，我们该如何做？
第1种可能的业务需求：要求Bean1.update()和Bean2.save()在同一个事务中执行。
第2种可能的业务需求：要求不管Bean1.update() 的事务是否成功，都需要记录操作日志。

public class Bean1 { 
     public void update(){//注意：下面省略了一些代码
Connection conn = null;
conn.setAutoCommit(false);
     Statement.executeUpdate(“update account set amount=? whereid=?");
     }
}
public class Bean2 {
     public void save(){//注意：下面省略了一些代码
Connection conn = null;
conn.setAutoCommit(false);
     Statement.executeUpdate(“insert into Log (content) values(?)");
     }
}
使

用Spring，我们只需要通过声明式的事务属性配置就可以轻松地实现这两种业务需求
1.要求Bean1.update()和Bean2.save()的在同一个事务中执行
2.要求不管Bean1.update() 的事务是否成功，都需要记录日志。

@Transactional(propagation=Propagation.Required)
public void payment(){
      Bean1.update();//更新金额
      Bean2.save();//记录日志
}
 public class Bean1 {
     @Transactional(propagation=Propagation.Required)
     public void update(){
                 executeUpdate(“update account set amount=? whereid=?");
     }
}
public class Bean2 {
     @Transactional(propagation=Propagation.RequiresNew)
     public void save(){
executeUpdate(“insert into Log (content) values (?)");
     }
}

轻量级与重量级概念的划分
spring属于轻量级框架,还是重量框架?其实划分一个应用是否属于轻量级还是重量级,主要看它使用了多少服务.使用的服务越多,容器要为普通java对象做的工作就越多,必然会影响到应用的发布时间或者是运行性能.

对于spring容器，它提供了很多服务，但这些服务并不是默认为应用打开的，应用需要某种服务，还需要指明使用该服务，如果应用使用的服务很少，如:只使用了spring核心服务，那么我们可以认为此时应用属于轻量级的，如果应用使用了spring提供的大部分服务，这时应用就属于重量级。目前EJB容器就因为它默认为应用提供了EJB规范中所有的功能，所以它属于重量级。
使用Spring需要的jar
到http://www.springsource.org/download下载spring，然后进行解压缩，在解压目录中找到下面jar文件，拷贝到类路径下
dist\spring.jar
lib\jakarta-commons\commons-logging.jar
如果使用了切面编程(AOP),还需要下列jar文件
lib/aspectj/aspectjweaver.jar和aspectjrt.jar
lib/cglib/cglib-nodep-2.1_3.jar
如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件
lib\j2ee\common-annotations.jar
<?xml version="1.0" encoding="UTF-8"?>
<beansxmlns="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-2.5.xsd">
.....
</beans>
该配置模版可以从spring的参考手册或spring的例子中得到。配置文件的取名可以任意，文件可以存放在任何目录下，但考虑到通用性，一般放在类路径下。
编写spring配置文件时，不能出现帮助信息
由于spring的schema文件位于网络上，如果机器不能连接到网络，那么在编写配置信息时候就无法出现提示信息，解决方法有两种：
1。让机器上网，eclipse会自动从网络上下载schema文件并缓存在硬盘上。
2。手动添加schema文件,方法如下：
windwos->preferences->myeclipse->files andeditors->xml->xmlcatalog
点"add",在出现的窗口中的Key Type中选择URI,在location中选"Filesystem",然后在spring解压目录的dist/resources目录中选择spring-beans-2.5.xsd,回到设置窗口的时候不要急着关闭窗口,应把窗口中的KeyType改为Schemalocation,Key改为http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
实例化spring容器
实例化Spring容器常用的两种方式：

方法一:
在类路径下寻找配置文件来实例化容器
ApplicationContext ctx = newClassPathXmlApplicationContext(new String[]{"beans.xml"});

方法二:
在文件系统路径下寻找配置文件来实例化容器
ApplicationContext ctx = newFileSystemXmlApplicationContext(newString[]{“d:\\beans.xml“});
Spring的配置文件可以指定多个，可以通过String数组传入。
从spring容器中得到bean
当spring容器启动后，因为spring容器可以管理bean对象的创建，销毁等生命周期，所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建bean对象。从容器获取bean对象的代码如下：
ApplicationContext ctx = newClassPathXmlApplicationContext(“beans.xml”);
OrderService service =(OrderService)ctx.getBean("personService");
使用dom4j读取spring配置文件

public class ItcastClassPathXmlApplicationContext {
    private List<BeanDefinition> beanDefines = newArrayList<BeanDefinition>();
     publicItcastApplicationContext(String filename){
  init(filename);
     }
     private void init(String filename){
      SAXReader saxReader = new SAXReader();  
       Document document=null;  
       try{
        URL xmlpath =this.getClass().getClassLoader().getResource(filename);
        document =saxReader.read(xmlpath);
        Map<String,String> nsMap = newHashMap<String,String>();
       nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间
        XPath xsub =document.createXPath("//ns:beans/ns:bean");//创建beans/bean查询路径
       xsub.setNamespaceURIs(nsMap);//设置命名空间
        List<Element> beans =xsub.selectNodes(document);//获取文档下所有bean节点 
        for(Element element:beans){
           String id= element.attributeValue("id");//获取id属性值
           Stringclazz = element.attributeValue("class"); //获取class属性值      
          BeanDefinition beanDefine = new BeanDefinition(id, clazz);
          beanDefines.add(beanDefine);
        }  
       }catch(Exception e){  
          e.printStackTrace();
       }
    }
}

三种实例化bean的方式
1.使用类构造器实例化
<bean id=“orderService"class="cn.itcast.OrderServiceBean"/>
2.使用静态工厂方法实例化
<bean id="personService"class="cn.itcast.service.OrderFactory"factory-method="createOrder"/>
public class OrderFactory {
public static OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
3.使用实例工厂方法实例化:
<bean id="personServiceFactory"class="cn.itcast.service.OrderFactory"/>
<bean id="personService" factory-bean="personServiceFactory"factory-method="createOrder"/>
public class OrderFactory {
public OrderServiceBean createOrder(){
return new OrderServiceBean();
}
}
Bean的作用域
.singleton
在每个SpringIoC容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：
<bean id="xxx"class="cn.itcast.OrderServiceBean" lazy-init="true"/<
如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：
<beans default-lazy-init="true“ ...<
.prototype
每次从容器获取bean都是新的对象。

.request
.session
.global session
指定Bean的初始化方法和销毁方法
指定Bean的初始化方法和销毁方法
<bean id="xxx" class="cn.itcast.OrderServiceBean"init-method="init" destroy-method="close"/>
注入依赖对象
基本类型对象注入：
<bean id="orderService"class="cn.itcast.service.OrderServiceBean">
<constructor-arg index=“0” type=“java.lang.String”value=“xxx”/>//构造器注入
<property name=“name” value=“zhao/>//属性setter方法注入
</bean>
注入其他bean：
方式一
<bean id="orderDao"class="cn.itcast.service.OrderDaoBean"/>
<bean id="orderService"class="cn.itcast.service.OrderServiceBean">
<property name="orderDao" ref="orderDao"/>
</bean>
方式二(使用内部bean,但该bean不能被其他bean使用)
<bean id="orderService"class="cn.itcast.service.OrderServiceBean">
<property name="orderDao">
<bean class="cn.itcast.service.OrderDaoBean"/>
</property>
</bean>

集合类型的装配
public class OrderServiceBean {
private Set<String> sets = new HashSet<String>();
private List<String> lists = new ArrayList<String>();
private Properties properties = new Properties();
private Map<String, String> maps = new HashMap<String,String>();
....//这里省略属性的getter和setter方法
}

集合类型的装配

<bean id="order"class="cn.itcast.service.OrderServiceBean">
    <propertyname="lists">
         <list>
<value>lihuoming</value>
        </list>
     </property>
     <property name="sets">
        <set>
          <value>set</value>
       </set>
     </property>
    <property name="maps">
       <map>
           <entrykey="lihuoming" value="28"/>
      </map>
    </property>
    <property name="properties">
       <props>
<prop key="12">sss</prop>
      </props>
     </property>
</bean>

依赖注入
使用构造器注入
使用属性setter方法注入
使用Field注入（用于注解方式）

注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。

1.手工装配依赖对象
手工装配依赖对象，在这种方式中又有两种编程方式
1. 在xml配置文件中，通过在bean节点下配置，如
<bean id="orderService"class="cn.itcast.service.OrderServiceBean">
<constructor-arg index=“0” type=“java.lang.String”value=“xxx”/>//构造器注入
<property name=“name” value=“zhao/>//属性setter方法注入
</bean>
2.在java代码中使用@Autowired或@Resource注解方式进行装配。但我们需要在xml配置文件中配置以下信息：
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config/>
</beans>
这个配置隐式注册了多个对注释进行解析处理的处理器:AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor，RequiredAnnotationBeanPostProcessor
注：@Resource注解在spring安装目录的lib\j2ee\common-annotations.jar

2.自动装配依赖对象
在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
@Autowired
private PersonDao personDao;//用于字段上
@Autowired
public voidsetOrderDao(OrderDao orderDao) {//用于属性的setter方法上
this.orderDao = orderDao;
}
@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
@Autowired @Qualifier("personDaoBean")
private PersonDao personDao;

@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。名称可以通过@Resource的name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。
@Resource(name=“personDaoBean”)
private PersonDao personDao;//用于字段上
注意：如果没有指定name属性，并且按照默认的名称仍然找不到依赖对象时，@Resource注解会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。

依赖注入--自动装配依赖对象
对于自动装配，大家了解一下就可以了，实在不推荐大家使用。例子：
<bean id="..." class="..." />
autowire属性取值如下：
byType：按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的bean。如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null。
byName：按名称装配，可以根据属性的名称，在容器中寻找跟该属性名相同的bean，如果没有找到，即属性值为null。
constructor与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。
autodetect：通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

通过在classpath自动扫描方式把组件纳入spring容器中管理
前面的例子我们都是使用XML的bean定义来配置组件。在一个稍大的项目中，通常会有上百个组件，如果这些这组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找及维护起来也不太方便。spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件是一样的。要使用自动扫描机制，我们需要打开以下配置信息:
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scanbase-package="cn.itcast"/>
</beans>
其中base-package为需要扫描的包(含子包)。

@Service用于标注业务层组件、@Controller用于标注控制层组件（如struts中的action）、@Repository用于标注数据访问组件，即DAO组件。而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

JDK动态代理

public class JDKProxy implements InvocationHandler {
private Object targetObject;//代理的目标对象
public Object createProxyInstance(Object targetObject){
this.targetObject = targetObject;
returnProxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
this.targetObject.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[]args)
throws Throwable {
return method.invoke(this.targetObject,args);//把方法调用委派给目标对象
}
}

当目标类实现了接口，我们可以使用jdk的Proxy来生成代理对象。

使用CGLIB生成代理

public class CGLIBProxy implements MethodInterceptor {
private Object targetObject;//代理的目标对象
public Object createProxyInstance(Object targetObject){
this.targetObject = targetObject;
Enhancer enhancer = new Enhancer();//该类用于生成代理对象
enhancer.setSuperclass(this.targetObject.getClass());//设置父类
enhancer.setCallback(this);//设置回调用对象为本身
return enhancer.create();
}
public Object intercept(Object proxy, Method method, Object[]args,
MethodProxy methodProxy) throws Throwable {
return methodProxy.invoke(this.targetObject, args);
}
}

CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。