Spring框架(一)

1.1 专业术语了解

组件/框架设计
侵入式设计
    引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
例如： Struts框架

非侵入式设计
    引入了框架，对现有的类结构没有影响。
    例如：Hibernate框架 / Spring框架

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

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

区别：
 控制反转， 解决对象创建的问题 【对象创建交给别人】
 依赖注入，在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
AOP,面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。切面举例：事务、日志、权限;

1.2 Spring框架

a. 概述
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其他模块的支持
b. 开发步骤
spring各个版本中：
    在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】
        如2.5版本；
    在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】
        (如果要用依赖包，需要单独下载！)

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） 核心配置文件: 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>   
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容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        // 从容器中获取bean
        User user = (User) ac.getBean("user");

        System.out.println(user);
    }
}

1.3. 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();
    }

1.4. 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方法注入值

<!-- 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"
    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">

    <!-- ###############对象属性赋值############### -->

    <!--
        给对象属性注入值：
            # p 名称空间给对象的属性注入值
             (spring3.0以上版本才支持)
     -->
     <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

     <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>

     <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></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>

自动装配(了解)

?   根据名称自动装配：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提供的自动装配主要是为了简化配置； 但是不利于后期的维护。
(一般不推荐使用)

注解

注解方式可以简化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配置一起使用。
时间： 2024-10-04 23:21:30

Spring框架(一)的相关文章

spring框架中使用junt单元测试

前言: 该代码适用于与spring框架整合的项目 代码: dao层的junit测试父类,需要在spring配置中注入两个bean <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationM

Spring框架：SpringMVC详解

SpringMVC的工作流程.最先接触到请求的是DispatcherServlet,它会将请求根据配置文件转发到控制器,控制器返回视图名称和一个Model表示处理结果.DispatcherServlet再将处理结果发送给视图模板引擎,由它进行页面的渲染.下图是整个过程. 基本配置 声明servlet.首先要在web.xml中声明Spring的Servlet,代码如下: <servlet> <servlet-name>spring</servlet-name> <s

Spring框架初识（二）

1. AOP的相关概念       1.1 AOP概述         1.1.1 什么是AOP             AOP:全程是Aspect Oriented Programming 即面向切面编程.是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了

详细介绍spring框架（下篇）

上篇简单介绍了spring,下面详细介绍为什么需要spring框架? Spring带给我们什么 方便解耦,简化开发,通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合.有了Spring,用户不必再为单实例模式类.属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用. AOP编程的支持 通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付. 声明式事务的支持 在

细说shiro之五：在spring框架中集成shiro

官网:https://shiro.apache.org/ 1. 下载在Maven项目中的依赖配置如下: <!-- shiro配置 --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>${version.shiro}</version> </dependency&g

Spring框架环境搭建

环境要求:jdk  1.7 及以上.Spring版本:4.3.2 1.建立普通的java 工程 2.新建lib目录,并将一下5个核心jar包拷贝过来,并加入classpath中 下载地址: http://repo.spring.io/libs-release-local/org/springframework/spring/4.3.2.RELEASE/ 3.spring  配置文件的编写 在src下新建xml文件,并拷贝官网文档提供的模板内容到xml中,配置bean到xml中 4. 验证spri

step4---&gt;往工程中添加Spring框架----&gt;修改maven的配置文件pom.xml,向工程中添加spring框架的某些模块

1.本文内容: 本文介绍使用maven向自己的项目中添加各种框架的方法,即如何配置maven的pom.xml来让maven帮助管理这些框架(包括Spring.SpringMVC.hibernate框架等等). 2.使用maven向自己的工程中添加框架: 2.1概述 若想使用maven向自己的工程中添加三方框架(如Spring.SpringMVC等),需要先确保你的工程是maven工程,如果你还不知道该如何在myeclipse中建立一个maven web project,请参考相关教程. 2.2使

java框架----&gt;spring框架----&gt;使用实例

相关教程:1)spring官网相关实例 这是spring官网,该网址列举了spring框架的若干使用实例,如

FAQ系列 | Spring框架中调用存储过程失败

Spring框架中,调用存储过程同时还需要show create procedure权限,对于普通用户而言,还要授予 select on mysql.proc 权限才能正常 --------------------------------------分割线-------------------------------------- 知数堂 (http://zhishuedu.com)培训是由资深MySQL专家叶金荣.吴炳锡联合推出的专业优质培训品牌,主要有MySQL DBA实战优化和Python

[JavaEE] IBM - Spring 系列: Spring 框架简介

Spring AOP 和 IOC 容器入门 在这由三部分组成的介绍 Spring 框架的系列文章的第一期中,将开始学习如何用 Spring 技术构建轻量级的.强壮的 J2EE 应用程序.developerWorks 的定期投稿人 Naveen Balani 通过介绍 Spring 框架开始了他由三部分组成的 Spring 系列,其中还将介绍 Spring 面向方面的编程(AOP)和控制反转(IOC)容器. Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的.框架的主要优势之一