将琴存诗
人生 可以不要那么 耀 ,只需要有 一个  平凡的梦想  足以 。—— H.yf. -_^ RSS
Fork me on GitHub

spring 核心

1 Spring 

1.1 专业术语了解

1.1.1 组件/框架设计

侵入式设计

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

                   例如:     Struts框架

非侵入式设计

         引入了框架,对现有的类结构没有影响。

         例如:Hibernate框架 / Spring框架

1.1.2 IOC 控制反转:

         Inversion on Control , 控制反转 IOC

         对象的创建交给外部容器完成,这个就叫做控制反转.

         依赖注入,  dependency injection  处理对象的依赖关系

         区别: 

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

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

1.1.3 AOP

    Aspect Oriented Programming面向切面编程。

    切面,简单来说来可以理解为一个类,由很多重复代码形成的类。

         切面举例:事务、日志、权限;

 2 Spring概述

2.1 概述

Spring框架,可以解决对象创建以及对象之间依赖关系的一种框架。且可以和其他框架一起使用;Spring与Struts,  Spring与hibernate(起到整合(粘合)作用的一个框架)

Spring提供了一站式解决方案:

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

         2) Spring Web  Spring对web模块的支持。

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

                                spring mvc模式

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

         4) Spring ORM  spring对orm的支持:

                                既可以与hibernate整合,【session】

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

         5)Spring AOP  切面编程

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

2.2 开发步骤

spring各个版本中:

         在3.0以下的版本,源码有spring中相关的所有包【spring功能 + 依赖包】

         在3.0以上的版本,源码中只有spring的核心功能包【没有依赖包】

2.2.1 源码, jar文件:

  spring-framework-3.2.5.RELEASE

       commons-logging-1.1.3.jar           日志

  spring-beans-3.2.5.RELEASE.jar        bean节点

  spring-context-3.2.5.RELEASE.jar       spring上下文节点

  spring-core-3.2.5.RELEASE.jar         spring核心功能

  spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

以上是必须引入的5个jar文件,在项目中可以用户库管理!

2.2.2 核心配置文件: applicationContext.xml 

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

  约束参考:

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

<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">
</beans>   

 

2.2.3 API

 1 public class App {
 2 
 3     // 1. 通过工厂类得到IOC容器创建的对象
 4     @Test
 5     public void testIOC() throws Exception {
 6         // 创建对象
 7         // User user = new User();
 8         
 9         // 现在,把对象的创建交给spring的IOC容器
10         Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
11         // 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
12         BeanFactory factory = new XmlBeanFactory(resource);
13         // 得到容器创建的对象
14         User user = (User) factory.getBean("user");
15         
16         System.out.println(user.getId());
17         
18     }
19     
20     //2. (方便)直接得到IOC容器对象 
21     @Test
22     public void testAc() throws Exception {
23         // 得到IOC容器对象
24         ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
25         // 从容器中获取bean
26         User user = (User) ac.getBean("user");
27         
28         System.out.println(user);
29     }
30 }

 

 

2.3 bean对象创建的细节

 1 /**
 2      * 1) 对象创建: 单例/多例
 3      *     scope="singleton", 默认值, 即 默认是单例    【service/dao/工具类】
 4      *  scope="prototype", 多例;                 【Action对象】
 5      * 
 6      * 2) 什么时候创建?
 7      *       scope="prototype"  在用到对象的时候,才创建对象。
 8      *    scope="singleton"  在启动(容器初始化之前), 就已经创建了bean,且整个应用只有一个。
 9      * 3)是否延迟创建
10      *       lazy-init="false"  默认为false,  不延迟创建,即在启动时候就创建对象
11      *       lazy-init="true"   延迟初始化, 在用到对象的时候才创建对象
12      *    (只对单例有效)
13      * 4) 创建对象之后,初始化/销毁
14      *       init-method="init_user"       【对应对象的init_user方法,在对象创建爱之后执行 】
15      *    destroy-method="destroy_user"  【在调用容器对象的destriy方法时候执行,(容器用实现类)】
16      */
17     @Test
18     public void testIOC() throws Exception {
19         // 得到IOC容器对象  【用实现类,因为要调用销毁的方法】
20         ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
21         System.out.println("-----容器创建-----");
22         
23         // 从容器中获取bean
24         User user1 = (User) ac.getBean("user");
25         User user2 = (User) ac.getBean("user");
26         
27         System.out.println(user1);
28         System.out.println(user2);
29         
30         // 销毁容器对象 
31         ac.destroy();
32     }

3  SpringIOC容器

3.1 创建对象

SpringIOC容器,是spring核心内容。

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

IOC容器创建对象:

创建对象, 有几种方式:

1) 调用无参数构造器

2) 带参数构造器

3) 工厂创建对象

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

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

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context"
 6     xsi:schemaLocation="
 7         http://www.springframework.org/schema/beans
 8         http://www.springframework.org/schema/beans/spring-beans.xsd
 9         http://www.springframework.org/schema/context
10         http://www.springframework.org/schema/context/spring-context.xsd">
11     
12     <!-- ###############对象创建############### -->
13     
14     <!-- 1. 默认无参数构造器 
15     <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
16     -->
17     
18     <!-- 2. 带参数构造器 -->
19     <bean id="user2" class="cn.itcast.b_create_obj.User">
20         <constructor-arg index="0" type="int" value="100"></constructor-arg>
21         <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
22     </bean>
23     
24     <!-- 定义一个字符串,值是"Jack" ;  String s = new String("jack")-->
25     <bean id="str" class="java.lang.String">
26         <constructor-arg value="Jacks"></constructor-arg>
27     </bean>
28     <bean id="user3" class="cn.itcast.b_create_obj.User">
29         <constructor-arg index="0" type="int" value="100"></constructor-arg>
30         <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
31     </bean>
32     
33     
34     <!-- 3. 工厂类创建对象 -->
35     <!-- # 3.1 工厂类,实例方法 -->
36     <!-- 先创建工厂 -->
37     <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
38     <!-- 在创建user对象,用factory方的实例方法 -->
39     <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
40     
41     
42     <!-- # 3.2 工厂类: 静态方法 -->
43     <!-- 
44         class 指定的就是工厂类型
45         factory-method  一定是工厂里面的“静态方法”
46      -->
47     <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
48     
49 </beans>      
50 
51 
52 
53   

 

 

3.2 对象依赖关系

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

         1) 通过构造函数

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

         3) p名称空间

         4)自动装配(了解)

         5) 注解

3.2.1 (常用)Set方法注入值

 1 <!-- dao instance -->
 2     <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
 3 
 4     <!-- service instance -->
 5     <bean id="userService" class="cn.itcast.c_property.UserService">
 6         <property name="userDao" ref="userDao"></property>
 7     </bean>
 8     
 9     <!-- action instance -->
10     <bean id="userAction" class="cn.itcast.c_property.UserAction">
11         <property name="userService" ref="userService"></property>
12     </bean>

 

3.2.2 内部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>

 

3.2.3 p 名称空间注入属性值 (优化)

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context"
 6     xsi:schemaLocation="
 7         http://www.springframework.org/schema/beans
 8         http://www.springframework.org/schema/beans/spring-beans.xsd
 9         http://www.springframework.org/schema/context
10         http://www.springframework.org/schema/context/spring-context.xsd">
11     
12     <!-- ###############对象属性赋值############### -->
13     
14     <!-- 
15         给对象属性注入值:
16             # p 名称空间给对象的属性注入值
17              (spring3.0以上版本才支持)
18      -->
19      <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
20      
21      <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
22      
23      <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>
24     
25     
26     <!-- 传统的注入: 
27      <bean id="user" class="cn.itcast.c_property.User" >
28          <property name="name" value="xxx"></property>
29      </bean>
30     -->
31     <!-- p名称空间优化后 -->
32     <bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
33      
34 </beans>   

3.2.4 # 自动装配(了解)

ü  根据名称自动装配:autowire="byName"

         -à 自动去IOC容器中找与属性名同名的引用的对象,并自动注入

<!-- ###############自动装配############### -->  
    <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>

也可以定义到全局, 这样就不用每个bean节点都去写autowire=”byName”

<?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" default-autowire="byName">   根据名称自动装配(全局)
    
    <!-- ###############自动装配############### -->  
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>    
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
</beans>   

ü  根据类型自动装配:autowire="byType"

必须确保改类型在IOC容器中只有一个对象;否则报错。

<?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" default-autowire="byType">
    
    <!-- ###############自动装配############### -->  
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>    
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
    
    <!-- 如果根据类型自动装配: 必须确保IOC容器中只有一个该类型的对象 -->
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
    
    
    <!--   报错: 因为上面已经有一个该类型的对象,且使用了根据类型自动装配
    <bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
     -->
</beans>  

总结:

         Spring提供的自动装配主要是为了简化配置; 但是不利于后期的维护。

3.2.5 注解

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

 

使用注解步骤:

         1)先引入context名称空间

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

         2)开启注解扫描

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

         3)使用注解

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

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

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

 

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

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

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

@Resource     属性注入

总结:

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

 

posted @ 2017-08-23 18:22 loveincode 阅读(...) 评论(...) 编辑 收藏
最简单即最美
有了信仰,自己要坚持努力 2017.07.09 21:34