学习笔记之Spring框架

1.Spring框架的作用：

简单来说，Spring主要就是用来处理dao层，service层以及action层的对象的创建以及对象的依赖关系。

2.专业术语

组件/框架设计：

        侵入式设计

                      

                  引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。

                   例如：     Struts框架

         非侵入式设计

                 引入了框架，但对现有的类结构没有影响，例如：Hiernate框架和Spring框架

控制反转：

            Inversion on Control,控制反转IOC,对象的创建交给外部容器完成，这个就叫做控制反转。

依赖注入：

        dependency injection,处理对象的依赖。

二者区别：

          控制反转是解决对象创建的问题【对象的创建交给别人】，

          依赖注入，是在创建完对象后，对象关系的处理就是依赖注入【通过set方法注入】

AOP

        面向切面编程，所谓切面，可以理解为一个类，由很多重复代码形成的类。

      切面举例：事务，日志，权限。

3.概述

        Spring框架提供了一站式解决方案：

               

        1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系

         2） SpringWeb  Spring对web模块的支持。

                                                        -> 可以与struts整合,让struts的action创建交给spring

                                                       -> spring mvc模式

         3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

         4） SpringORM  spring对orm的支持：

                                                        -> 既可以与hibernate整合，【session】

                                                        ->也可以使用spring的对hibernate操作的封装

         5）Spring AOP  切面编程

         6）SpringEE   spring 对javaEE其他模块的支持

  开发步骤

             1.引入jar包

        2.写配置文件

          

         核心配置文件: applicationContext.xml 

     Spring配置文件：applicationContext.xml/ bean.xml

约束参考：

spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">

3.API

public class App {

	// 1. 通过工厂类得到IOC容器创建的对象
	@Test
	public void testIOC() throws Exception {
		// 创建对象
		// User user = new User();
		
		// 现在，把对象的创建交给spring的IOC容器
		Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
		// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
		BeanFactory factory = new XmlBeanFactory(resource);
		// 得到容器创建的对象
		User user = (User) factory.getBean("user");
		
		System.out.println(user.getId());
		
	}
	
	//2. （方便）直接得到IOC容器对象 
	@Test
	public void testAc() throws Exception {
		// 得到IOC容器对象,<span style="color:#FF0000;">这里可以传入多个配置文件路径，用逗号隔开，也可以用数组</span>
		ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		// 从容器中获取bean
		User user = (User) ac.getBean("user");
		
		System.out.println(user);
	}
}

4. bean对象创建的细节

/**
	 * 1) 对象创建： 单例/多例
	 * 	scope="singleton", 默认值， 即 默认是单例	【service/dao/工具类】
	 *  scope="prototype", 多例； 				【Action对象】
	 * 
	 * 2) 什么时候创建?
	 * 	  scope="prototype"  在用到对象的时候，才创建对象，懒加载。
	 *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
	 * 3)是否延迟创建
	 * 	  lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
	 * 	  lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
	 *    （只对单例有效）
	 * 4) 创建对象之后，初始化/销毁
	 * 	  init-method="init_user"       【对应对象的init_user方法，在对象创建爱之后执行 】
	 *    destroy-method="destroy_user"  【在调用容器对象的destriy方法时候执行，(容器用实现类)】
	 */
	@Test
	public void testIOC() throws Exception {
		// 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
		System.out.println("-----容器创建-----");
		
		// 从容器中获取bean
		User user1 = (User) ac.getBean("user");
		User user2 = (User) ac.getBean("user");
		
		System.out.println(user1);
		System.out.println(user2);
		
		// 销毁容器对象 
		ac.destroy();
	}

5. SpringIOC容器

1）创建对象

SpringIOC容器，是spring核心内容。

作用：创建对象 & 处理对象的依赖关系

 

IOC容器创建对象：

创建对象, 有几种方式：

     1） 调用无参数构造器

     2） 带参数构造器

     3） 工厂创建对象

                   工厂类，静态方法创建对象

                   工厂类，非静态方法创建对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- ###############对象创建############### -->
	
	<!-- 1. 默认无参数构造器 
	<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
	-->
	
	<!-- 2. 带参数构造器 -->
	<bean id="user2" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
	</bean>
	
	<!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
	<bean id="str" class="java.lang.String">
		<constructor-arg value="Jacks"></constructor-arg>
	</bean>
	<bean id="user3" class="cn.itcast.b_create_obj.User">
		<constructor-arg index="0" type="int" value="100"></constructor-arg>
		<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
	</bean>
	
	
	<!-- 3. 工厂类创建对象 -->
	<!-- # 3.1 工厂类，实例方法 -->
	<!-- 先创建工厂 -->
	<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
	<!-- 在创建user对象，用factory方的实例方法 -->
	<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
	
	
	<!-- # 3.2 工厂类： 静态方法 -->
	<!-- 
		class 指定的就是工厂类型
		factory-method  一定是工厂里面的“静态方法”
	 -->
	<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
	
</beans>      

2）对象依赖关系

Spring中，如何给对象的属性赋值?  【DI, 依赖注入】

         1) 通过构造函数

         2) 通过set方法给属性注入值

         3)p名称空间

         4)自动装配(了解)

         5)注解

个人觉得还是第五种方式，注解最好用。

#常用的set方法注入值

    注意：要先写对象的set方法，再配置才有效。比如在UserService类中创建方法setUserDao();

<!-- dao instance -->
	<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

	<!-- service instance -->
	<bean id="userService" class="cn.itcast.c_property.UserService">
		<property name="userDao" ref="userDao"></property>
	</bean>
	
	<!-- action instance -->
	<bean id="userAction" class="cn.itcast.c_property.UserAction">
		<property name="userService" ref="userService"></property>
	</bean>

#内部bean

!-- ##############内部bean############## -->
	<bean id="userAction" class="cn.itcast.c_property.UserAction">
		<property name="userService">
			<bean class="cn.itcast.c_property.UserService">
				<property name="userDao">
					<bean class="cn.itcast.c_property.UserDao"></bean>
				</property>
			</bean>
		</property>
	</bean>

#P名称空间注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    <span style="color:#FF0000;">xmlns:p="http://www.springframework.org/schema/p"</span>
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- ###############对象属性赋值############### -->
	
	<!-- 
		给对象属性注入值：
			# p 名称空间给对象的属性注入值
			 (spring3.0以上版本才支持)
	 -->
	 <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
	 
	 <bean id="userService" class="cn.itcast.c_property.UserService" <span style="color:#FF0000;">p:userDao-ref="userDao"</span>></bean>
	 
	 <bean id="userAction" class="cn.itcast.c_property.UserAction" <span style="color:#FF0000;">p:userService-ref="userService"</span>></bean>
	
	
	<!-- 传统的注入： 
	 <bean id="user" class="cn.itcast.c_property.User" >
	 	<property name="name" value="xxx"></property>
	 </bean>
	-->
	<!-- p名称空间优化后 -->
	<bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
	 
</beans>   

#自动装配

<!-- ###############自动装配############### -->  
	<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>	
	<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
	<!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->
	<bean id="userAction" 
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

Spring提供的自动装配主要是为了简化配置；但是不利于后期的维护。就是基本没什么用。

#注解

注解方式可以简化spring的IOC容器的配置!

 

使用注解步骤：

         1）先引入context名称空间

                   xmlns:context="http://www.springframework.org/schema/context"

         2）开启注解扫描

                   <context:component-scanbase-package="cn.itcast.e_anno2"></context:component-scan>

         3）使用注解

                   通过注解的方式，把对象加入ioc容器。

 

            创建对象以及处理对象依赖关系，相关的注解：

           @Component   指定把一个对象加入IOC容器

 

          @Repository   作用同@Component； 在持久层使用

         @Service      作用同@Component； 在业务逻辑层使用

         @Controller    作用同@Component； 在控制层使用

 

         @Resource     属性注入

 

总结：

         1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
         2） 注解可以和XML配置一起使用。