Spring学习笔记1

前言

Spring框架的学习路线:

  1. Spring第一天:Spring的IOC容器之XML的方式,Spring框架与Web项目整合
  2. Spring第二天:Spring的IOC容器之注解的方式,Spring的AOP技术
  3. Spring第三天:Spring的事务管理、Spring框架的JDBC模板
  4. Spring第四天:SSH三大框架的整合

这是第一天学习大纲:

一、 Spring框架的概述

1.1 技术分析之什么是Spring框架

1、Spring框架的概述:(更详细参考百度百科 spring

  • Spring是一个开源框架
  • Spring是于2003 年兴起的一个轻量级的Java开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。
  • 它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。
    Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以 从Spring中受益。
  • Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

引用百度百科上一段介绍:

Rod Johnson在2002年编著的《Expert one on one J2EE design and development》一书中,对Java EE 系统框架臃肿、低效、脱离现实的种种现状提出了质疑,并积极寻求探索革新之道。以此书为指导思想,他编写了interface21框架,这是一个力图冲破J2EE传统开发的困境,从实际需求出发,着眼于轻便、灵巧,易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日,发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-on-one J2EE Development without EJB》,该书在Java世界掀起了轩然大波,不断改变着Java开发者程序设计和开发的思考方式。在该书中,作者根据自己多年丰富的实践经验,对EJB的各种笨重臃肿的结构进行了逐一的分析和否定,并分别以简洁实用的方式替换之。至此一战功成,Rod Johnson成为一个改变Java世界的大师级人物。

解释:最早做 Java 开发采用的是 sun 公司提供的 EJB 规范做开发,最开始没那么多框架。Rod Johnson 对开发过程诸如低效、臃肿、脱离现实种种现状提出质疑,并积极寻求探索革新之道,后来就有了 spring 框架。

2、EE开发分成三层结构

  • WEB层 – Spring MVC
    业务层 – Bean管理:(IOC)
    持久层 – Spring的 JDBC 模板. ORM模板用于整合其他的持久层框架

3、什么叫full-stack(一站式)开发?

首先来说 Java EE 开发一般分三层,WEB 层、业务层、持久层,每一层要干的事不一样。如下:

Spring 属于业务层一个框架,那为什么叫一站式开发呢?这样来解释,如果 WEB 层你不想使用 Struts2 框架,Spring 框架提供了一个叫 SpringMVC 模块(属于 Spring 的一部分),它就可以当做 WEB 层小框架,处理 web 层事情;如果持久层不想使用 Hibernate 框架,Spring 框架提供了一个叫 SpringJDBC 模板(它能帮忙操作数据库),这样它就能当做持久层解决方案。

这样看来,如果我不使用其他框架,只用 Spring 框架也是能做 Java EE 开发。并且如果你不想使用 SpringMVC 模块做 WEB 层也是可以的,仍然可以使用 Struts2 框架,因为 Spring 框架可以帮忙集成和整合 Struts2 框架;如果持久层你不想使用 SpringJDBC 模板,使用其他一些持久层框架如 Hibernate、Mybatis 也是可以,Spring 框架也可以去整合它们。

另外,如果没有 Spring 框架,只用 Struts2 开发也是没问题,但可能效率等方面就不是很好了。但有了 Spring 框架,Struts2 会更牛,它的管理可能更方便、开发更简单。简单来说:只用 Struts2 去开发也可以,但是有了 Spring 框架开发会更好。

再次小结:如果没有 Spring 框架也能做企业级开发,但有了 Spring,做开发更规范,程序扩展性和维护等方面更好。-----> 它能解决企业级开发的复杂性。

另外关于 Spring 框架,我们再来了解下它与 Spring boot、Spring Clound 的区别:Spring SpringMVC SpringBoot SpringCloud概念、关系及区别

1.2 技术分析之Spring框架的特点

1、 为什么要学习Spring的框架

  • 方便解耦,简化开发
    • Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理
  • AOP编程的支持
    • Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
  • 声明式事务的支持
    • 只需要通过配置就可以完成对事务的管理,而无需手动编程
  • 方便程序的测试
    • Spring对Junit4支持,可以通过注解方便的测试Spring程序
  • 方便集成各种优秀框架
    • Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts2、Hibernate、MyBatis、Quartz等)的直接支持
  • 降低JavaEE API的使用难度
    • Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

2、Spring框架的版本:

  • Sring3.x 和 Spring4.x 的版本

二、SpringIOC的快速入门

1、什么是 IOC 的功能?

  • IoC(Inverse of Control):控制反转,将对象的创建权反转给Spring!!
  • 使用 IOC 可以解决的程序耦合性高的问题!!

如上图,解释一下。

假如要做一个保存客户信息的功能,那么我们在代码中可能要在 service 层 new 一个类,再到 dao 层 new 一个类(类比上图即资源),可以看到,资源的创建权利来自该功能。其实这样不是不可以,只是不好,过度耦合了。有了 Spring 框架,那现在可以交给 Spring 框架了。

IOC 的编写过程:(先要了解工厂模式,参考 工厂模式——看这一篇就够了

  • App —> 工厂 —> 资源(功能和资源分开了,但是有个问题,资源和工厂还存在耦合)

  • App —> 工厂 —> XML文件 —> 资源

    在 xml 文件中配置,配置什么,就创建什么。工厂读取 xml 文件,工厂负责生产这些对象。程序中用到对象就到工厂拿就可以。

IOC 的底层实现原理:

编写步骤:

1. 步骤一:下载Spring框架的开发包
    * 官网:http://spring.io/
    * 下载地址:http://repo.springsource.org/libs-release-local/org/springframework/spring 解压出来:(Spring目录结构:)
        * docs      -- API和开发规范
        * libs      -- jar包和源码
        * schema    -- 约束

2. 步骤二:创建JavaWEB项目,引入Spring的开发包
    * 引入Spring框架IOC核心功能需要的具体的jar包
        * Spring框架的IOC的功能,那么根据Spring框架的体系结构图能看到,只需要引入如下的jar包
            * Beans
            * Core
            * Context
            * Expression Language

        * Spring框架也需要引入日志相关的jar包
            * 在spring-framework-3.0.2.RELEASE-dependencies/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1
                * com.springsource.org.apache.commons.logging-1.1.1.jar

            * 还需要引入log4j的jar包 spring-framework-3.0.2.RELEASE-dependencies\org.apache.log4j\com.springsource.org.apache.log4j\1.2.15
                * com.springsource.org.apache.log4j-1.2.15.jar

3. 步骤三:创建对应的包结构,编写Java的类,要注意:以后使用Spring框架做开发,都需要来编写接口与实现类!!
    * com.itcast.demo1
        * UserService           -- 接口
        * UserServiceImpl       -- 具体的实现类

4. 步骤四:想把UserServiceImpl实现类的创建交给Spring框架来管理,需要创建Spring框架的配置文件,完成配置
    * 在src目录下创建applicationContext.xml的配置文件,名称是可以任意的,但是一般都会使用默认名称!!

    * 引入spring的约束,需要先找到具体的约束头信息!!
        * spring-framework-3.2.0.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
        * 具体的约束如下:      
            <beans xmlns="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.xsd">
            </beans>

    * 完成UserService的配置
        <!-- Spring的快速入门 -->
        <bean id="userService" class="com.itcast.demo1.UserServiceImpl"/>

5. 步骤五:编写测试程序,采用Spring框架的工厂方式来获取到UserService接口的具体实现类!!
    public void demo2(){
        // 使用Spring的工厂:
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂获得类:
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.sayHello();
    }

关于第①步: 相关 Spring 文件有如下:

但我们用到的核心的是 spring-framework-4.2.4.RELEASE-dist.zip 该文件,把其解压出来可以看到存在 docs文件夹(文档) 和 scheme文件夹(约束);另外一个文件 spring-framework-3.0.2.RELEASE-dependencies.zip是有关依赖包的文件,如文件上传、连接池、日志相关包。

关于第②步:

看上图上半部分 Spring Framework Runtime,可以看到核心容器下有四个模块,上面其他功能都依赖该四个模块。所以只要导入四个包就可以。(在这里,另外导入了spring-framework-3.0.2.RELEASE-dependencies.zip中两个依赖包,第一个为日志规范,第二个为日志实现)

关于日志,其实还少了一个配置文件 log4j.properties,内容:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

把日志配置文件粘贴到项目 src 目录下。

注:log4j.rootLogger=info, stdout 中 info 表示级别,stdout 表示向控制台输出。如 info 可改为 off 则不会在输出日志信息,还可设置为 debug。

代码演示:

public class Demo1 {
    //创建日志对象
    private Logger log = Logger.getLogger(Demo1.class);

    @Test
    public void run1() {
        //		System.out.println("执行了...");
        log.info("执行了...");
    }
}

结果:

关于第③步:

UserService.java:

public interface UserService {
	public void sayHello();
}

UserServiceImpl.java:

public class UserServiceImpl implements UserService {
	public void sayHello() {
		System.out.println("Hello Spring!");
	}
}

使用原来的方式:

//原来的方式
@Test
public void run1() {
    //创建实现类
    //UserServiceImpl us = new UserServiceImpl(); 
    UserService us = new UserServiceImpl();
    us.sayHello();
}

可以看到打印输出:Hello Spring!

关于第④⑤步: 在 src 目录下创建applicationContext.xml的配置文件,写上相关配置信息

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
   	<!-- 使用bean标签 -->
   	<bean id="userService" class="com.strivebo.demo2.UserServiceImpl">
   		<property name="name" value="小凤"/>
   	</bean>
</beans>

使用 Spring 框架的方式:

//使用 Spring 框架的方式
@Test
public void run2() {
    // 创建工厂,加载核心配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 从工厂中获取到对象
    UserServiceImpl usi = (UserServiceImpl) ac.getBean("userService");
    //一般使用如下接口的方式
    //UserService usi = (UserService) ac.getBean("userService");
    // 调用对象的方法执行
    usi.sayHello();
}

同样也是能输出:Hello Spring!

1.3 入门总结之Spring框架中的工厂(了解)

1. ApplicationContext接口
    * 使用ApplicationContext工厂的接口,使用该接口可以获取到具体的Bean对象
    * 该接口下有两个具体的实现类
        * ClassPathXmlApplicationContext            -- 加载类路径下的Spring配置文件
        * FileSystemXmlApplicationContext           -- 加载本地磁盘下的Spring配置文件

2. BeanFactory工厂(是Spring框架早期的创建Bean对象的工厂接口)
    * 使用BeanFactory接口也可以获取到Bean对象
        public void run(){
            BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
            UserService us = (UserService) factory.getBean("us");
            us.sayHello();
        }

    * BeanFactory和ApplicationContext的区别
        * BeanFactory               -- BeanFactory采取延迟加载,第一次getBean时才会初始化Bean
        * ApplicationContext        -- 在加载applicationContext.xml时候就会创建具体的Bean对象的实例,还提供了一些其他的功能
            * 事件传递
            * Bean自动装配
            * 各种不同应用层的Context实现

三、IoC容器XML的方式

3.1 入门总结之配置Spring框架编写XML的提示:

1. 步骤一:先复制, http://www.springframework.org/schema/beans/spring-beans.xsd    
2. 步骤二:打开 Eclipse的Windows-->Preference,搜索XML Catalog,点击Add按钮
3. 步骤三:先选择Location的schema的约束地址
    * E:\class\2016\JavaEE28\day35_Spring框架第一天\资料\spring-framework-4.2.4.RELEASE-schema\beans\spring-beans-4.2.xsd
4. 步骤四:注意:Key type要选择:Schema location
5. 步骤五:Key把http://www.springframework.org/schema/beans/spring-beans.xsd复制上

3.2 技术分析之Spring框架的Bean管理的配置文件方式

3.3.1 Spring框架中标签的配置
1. id属性和name属性的区别
    * id        -- Bean起个名字,在约束中采用ID的约束,唯一
        * 取值要求:必须以字母开始,可以使用字母、数字、连字符、下划线、句话、冒号  id:不能出现特殊字符

    * name      -- Bean起个名字,没有采用ID的约束(了解)
        * 取值要求:name:出现特殊字符.如果<bean>没有id的话 , name可以当做id使用
        * Spring框架在整合Struts1的框架的时候,Struts1的框架的访问路径是以/开头的,例如:/bookAction

2. class属性          -- Bean对象的全路径
3. scope属性          -- scope属性代表Bean的作用范围
    * singleton         -- 单例(默认值)
    * prototype         -- 多例,在Spring框架整合Struts2框架的时候,Action类也需要交给Spring做管理,配置把Action类配置成多例!!
    * request           -- 应用在Web项目中,每次HTTP请求都会创建一个新的Bean
    * session           -- 应用在Web项目中,同一个HTTP Session 共享一个Bean
    * globalsession     -- 应用在Web项目中,多服务器间的session

4. Bean对象的创建和销毁的两个属性配置(了解)
    * 说明:Spring初始化bean或销毁bean时,有时需要作一些处理工作,因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法
    * init-method       -- 当bean被载入到容器的时候调用init-method属性指定的方法
    * destroy-method    -- 当bean从容器中删除的时候调用destroy-method属性指定的方法
        * 想查看destroy-method的效果,有如下条件
            * scope= singleton有效
            * web容器中会自动调用,但是main函数或测试用例需要手动调用(需要使用ClassPathXmlApplicationContext的close()方法)

关于 scope 属性 为 singleton(单例)和 prototype(多例)的理解:

像以前的写程序方式,每次要在 service 得 new XxxDao(),可以看出,每次发送请求,都得 new 一个对象,这就是多例。(每个请求都有一个实例对象)

那什么是单例呢?单例相当于整个运行环境中就这一个实例对象。就比如 new XxxDao() 这个 dao 对象已经创建好了,在内存当中就这一个实例对象。

关于 Spring的 bean 的单例和多例作用域更多介绍参考网上资料:【Spring学习17】bean作用域:单例和多例

在 Spring 里,通过容器创建的对象默认是singleton单例(这里要注意的是 singleton 作用域和 GOF 设计模式中的单例是不同的) ,单例就是在整个容器的生命周期,只会存在一个共享的bean实例。

如果某个 bean 被标记为多例,则每次请求使用该对象时,都会创建一个新的 bean 实例。比如将这个 bean 注入到另一个 bean 中,或者在程序中调用getBean("beanid")方法,都会触发生成一个新的 bean 实例,相当于 new 的操作。

关于 init-method 和 destory-method 属性,见代码演示:

<!-- 使用bean标签 -->
<bean id="userService" class="com.strivebo.demo2.UserServiceImpl" init-method="init" destroy-method="destory">
    <property name="name" value="小凤"/>
</bean>

UserServiceImpl.java:

public class UserServiceImpl implements UserService {
	public void sayHello() {
		System.out.println("Hello Spring!");
	}	
	public void init() {
		System.out.println("初始化...");
	}
	public void destory() {
		System.out.println("销毁...");
	}
}
3.3.2 依赖注入(DI)

什么是依赖注入?

如上图,我们想做一个功能,以前都是 service 层 new Dao().xxx ,可以看到 service 层需要依赖 dao,这就叫依赖。现在有了 Spring ,service 和 dao 都可以交给 Spring 管理。在创建 service 的时候,发现需要 dao,则会注入一个 dao,那 service 就这样有了 dao,于是便可以调用 dao 对象的方法。代码来理解:

UserServiceImpl.java:

public class UserServiceImpl implements UserService {
    private String name;
    public void setName(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello Spring!" + name);
    }
}

以前方法都是:

public void run1() {
    //创建实现类
    UserServiceImpl us = new UserServiceImpl();
    us.setName("小明");
    us.sayHello();
}

可以看到输出:Hello Spring!小明

现在方式——依赖注入方式:

applicationContext.xml:

<bean id="userService" class="com.strivebo.demo2.UserServiceImpl">
    <property name="name" value="小凤"/>
</bean>

执行:

@Test
public void run2() {
    // 创建工厂,加载核心配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService usi = (UserService) ac.getBean("userService");
    // 调用对象的方法执行
    usi.sayHello();
}

输出结果:Hello Spring!小凤

-------------------------------------------代码完整演示过程---------------------------------------------

①以前的方式:

CustomerDaoImpl.java:

public class CustomerDaoImpl {
    public void save(){
        System.out.println("我是持久层dao....");
    }
}

CustomerServiceImpl.java:

public class CustomerServiceImpl {
    public void save(){
        System.out.println("我是业务层service....");
        new CustomerDaoImpl().save();
    }	
}

执行:

@Test
public void run1(){	//原始方式
    CustomerServiceImpl cs = new CustomerServiceImpl();
    cs.save();
}

结果:

②依赖注入方式:

CustomerServiceImpl.java:

public class CustomerServiceImpl {
    // 提供成员属性,提供set方法
    private CustomerDaoImpl customerDao;
    public void setCustomerDao(CustomerDaoImpl customerDao) {
        this.customerDao = customerDao;
    }	
    public void save(){
        System.out.println("我是业务层service....");
        // 原来编写方式
        // new CustomerDaoImpl().save();
        // Spring的方式
        customerDao.save();
    }
}

applicationContext.xml 文件添加如下:(即把 customeDao 注入到 customerService 中)

<!-- 演示的依赖注入 -->
<bean id="customerDao" class="com.strivebo.demo3.CustomerDaoImpl"/>
<bean id="customerService" class="com.strivebo.demo3.CustomerServiceImpl">
    <property name="customerDao" ref="customerDao"/>
</bean> 	

运行:

@Test
public void run2(){	//Spring 方式
    // 创建工厂,加载配置文件,CustomerDaoImpl创建了,CustomerServiceImpl被创建了,
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    CustomerServiceImpl cs = (CustomerServiceImpl) ac.getBean("customerService");
    cs.save();
}
3.3.3 Spring框架的属性注入
1. 对于类成员变量,常用的注入方式有两种
    * 构造函数注入
    * 属性setter方法注入

2. 在Spring框架中提供了前两种的属性注入的方式
    1. 构造方法的注入方式,两步
        * 编写Java的类,提供构造方法
            public class Car {
                private String name;
                private double money;
                public Car(String name, double money) {
                    this.name = name;
                    this.money = money;
                }
                @Override
                public String toString() {
                    return "Car [name=" + name + ", money=" + money + "]";
                }
            }

        * 编写配置文件
            <bean id="car" class="com.itheima.demo4.Car">
                <constructor-arg name="name" value="大奔"/>
                <constructor-arg name="money" value="100"/>
            </bean>
		
		* 或者
            <bean id="car" class="com.itheima.demo4.Car">
                <constructor-arg index="0" value="长安奔奔"/>
                <constructor-arg index="1" value="45000"/>
            </bean>

    2. 属性的setter方法的注入方式
        * 编写Java的类,提供属性和对应的set方法即可
        * 编写配置文件

    3. 如果Java类的属性是另一个Java的类,那么需要怎么来注入值呢?
        * <property name="name" rel="具体的Bean的ID或者name的值"/>
        * 例如:
            <bean id="person" class="com.itheima.demo4.Person">
                <property name="pname" value="美美"/>
                <property name="car2" ref="car2"/>
            </bean>
3.3.4 Spring的2.5版本中提供了一种:p名称空间的注入(了解)
1. 步骤一:需要先引入 p 名称空间
    * 在schema的名称空间中加入该行:xmlns:p="http://www.springframework.org/schema/p"

2. 步骤二:使用p名称空间的语法
    * p:属性名 = ""
    * p:属性名-ref = ""

3. 步骤三:测试
    * <bean id="person" class="com.itheima.demo4.Person" p:pname="老王" p:car2-ref="car2"/>
3.3.5 Spring的3.0提供了一种:SpEL注入方式(了解)
1. SpEL:Spring Expression Language是Spring的表达式语言,有一些自己的语法
2. 语法
    * #{SpEL}

3. 例如如下的代码
    <!-- SpEL的方式 -->
    <bean id="person" class="com.itheima.demo4.Person">
        <property name="pname" value="#{'小风'}"/>
        <property name="car2" value="#{car2}"/>
    </bean>

4. 还支持调用类中的属性或者方法
    * 定义类和方法,例如
        public class CarInfo {
            public String getCarname(){
                return "奇瑞QQ";
            }
        }
3.3.6 数组,集合(List,Set,Map),Properties等的注入
1. 如果是数组或者List集合,注入配置文件的方式是一样的
    <bean id="collectionBean" class="com.itheima.demo5.CollectionBean">
        <property name="arrs">
            <list>
                <value>美美</value>
                <value>小风</value>
            </list>
        </property>
    </bean>

2. 如果是Set集合,注入的配置文件方式如下:
    <property name="sets">
        <set>
            <value>哈哈</value>
            <value>呵呵</value>
        </set>
    </property>

3. 如果是Map集合,注入的配置方式如下:
    <property name="map">
        <map>
            <entry key="老王2" value="38"/>
            <entry key="凤姐" value="38"/>
            <entry key="如花" value="29"/>
        </map>
    </property>

4. 如果是properties属性文件的方式,注入的配置如下:
    <property name="pro">
        <props>
            <prop key="uname">root</prop>
            <prop key="pass">123</prop>
        </props>
    </property>
3.3.7 Spring框架的配置文件分开管理(了解)
1. 例如:在src的目录下又多创建了一个配置文件,现在是两个核心的配置文件,那么加载这两个配置文件的方式有两种!
    * 主配置文件中包含其他的配置文件:
        <import resource="applicationContext2.xml"/>

    * 工厂创建的时候直接加载多个配置文件:
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                    "applicationContext.xml","applicationContext2.xml");

-------------------------------------------- 来看一个属性注入比较全的配置文件 ----------------------------------------------

<?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"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
	
   	<!-- 使用bean标签 -->
   	<bean id="userService" class="com.itheima.demo2.UserServiceImpl">
   		<property name="name" value="小凤"/>
   	</bean>
   	
   	<!-- 演示的依赖注入 -->
   	<bean id="customerDao" class="com.itheima.demo3.CustomerDaoImpl"/>
   	<bean id="customerService" class="com.itheima.demo3.CustomerServiceImpl">
   		<property name="customerDao" ref="customerDao"/>
   	</bean>
   	
   	<!-- 演示的构造方法的注入的方式 -->
   	<bean id="car1" class="com.itheima.demo4.Car1">
   		<!-- <constructor-arg name="cname" value="奇瑞QQ"/>
   		<constructor-arg name="price" value="25000"/> -->
        
   		<constructor-arg index="0" value="囚车"/>
   		<constructor-arg index="1" value="545000"/>
   	</bean>
    
   	<!-- 演示的依赖注入 -->
   	<bean id="person" class="com.itheima.demo4.Person">
   		<constructor-arg name="pname" value="美美"/>
   		<constructor-arg name="car1" ref="car1"/>
   	</bean>
   	
   	<!-- 采用set方法注入
   	<bean id="car2" class="com.itheima.demo4.Car2">
   		<property name="cname" value="二八自行车"/>
   		<property name="price" value="1000"/>
   	</bean> -->
   	
   	<!-- 采用p名称空间注入的方式(了解) 
   		<bean id="car2" class="com.itheima.demo4.Car2" p:cname="保时捷" p:price="1000000"/>
	-->
	
	<!-- 使用SPEL方式注入 -->
	<bean id="car2" class="com.itheima.demo4.Car2">
		<property name="cname" value="#{'福特野马'}"/>
		<property name="price" value="#{450000}"/>
	</bean>
	
	<!-- 注入集合 
	<bean id="user" class="com.itheima.demo4.User">
		<property name="arrs">
			<list>
				<value>哈哈</value>
				<value>呵呵</value>
				<value>嘿嘿</value>
			</list>
		</property>
		
		<property name="list">
			<list>
				<value>美美</value>
				<value>小凤</value>
			</list>
		</property>
		
		<property name="map">
			<map>
				<entry key="aaa" value="小苍"/>
				<entry key="bbb" value="小泽"/>
			</map>
		</property>
		
		<property name="pro">
			<props>
				<prop key="username">root</prop>
				<prop key="password">1234</prop>
			</props>
		</property>
	</bean>
	-->
	
	<!-- 引入其他的配置文件 
		<import resource="applicationContext2.xml"/>
	-->
</beans>

四、在web项目中集成Spring

CustomerDao.java:

public interface CustomerDao {
	public void save();
}

CustomerDaoImpl.java:

public class CustomerDaoImpl implements CustomerDao {
	
	public void save() {
		System.out.println("持久层:保存客户...");
	}
}

CustomerService.java:

public interface CustomerService {
	public void save();	
}

CustomerServiceImpl.java:

public class CustomerServiceImpl implements CustomerService {
	private CustomerDao customerDao;
	public void setCustomerDao(CustomerDao customerDao) {
		this.customerDao = customerDao;
	}
    
	public void save() {
		System.out.println("业务层:保存客户...");
		cust omerDao.save();
	}
}

配置文件 applicationContext.xml 添加如下:

<!-- 配置客户的业务层 -->
<bean id="customerService" class="com.itheima.service.CustomerServiceImpl">
    <property name="customerDao" ref="customerDao"/>
</bean>

<!-- 配置持久层 -->
<bean id="customerDao" class="com.itheima.dao.CustomerDaoImpl"/>

CustomerAction.java:

/**
 * 客户的Action
 * @author Administrator
 */
public class CustomerAction extends ActionSupport{
	
	private static final long serialVersionUID = 113695314694166436L;
	
	/**
	 * 保存客户
	 * @return
	 */
	public String save(){
		System.out.println("WEB层:保存客户...");
		// 使用工厂
		/*ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerService cs = (CustomerService) ac.getBean("customerService");
		cs.save();*/
		
		ServletContext servletContext = ServletActionContext.getServletContext();
		// 需要使用WEB的工厂的方式
		WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
		CustomerService cs = (CustomerService) context.getBean("customerService");
		cs.save();
		
		return NONE;
	}
}

页面每次点击保存客户,则会调用 Action 层(WEB层) save() 方法,再调用 Service 层(业务层),最后调用 Dao 层(持久层)。

但这里会出现一个问题,每访问一次都会加载一次配置文件(即每次请求都会创建一个工厂类,服务器端的资源就浪费了,一般情况下一个工程只有一个Spring的工厂类就OK了)。需要解决该问题,该怎么解决呢?整合来了。

第一步:找到spring-framework-4.2.4.RELEASE\libs\spring-web-4.2.4.RELEASE.jar复制到 WEB-INF\lib 目录(即导入该 jar 包);

第二步:得先温故 Servlet 监听器有关知识了,如图

  • 有这么一类监听器,监听 ServletContext 对象的创建和销毁的。

  • ServletContext 对象什么时候创建?当服务器启动时候创建,当服务器销毁时候关闭。

当服务器启动, ServletContext 对象创建,则监听器对象的方法执行,加载 applicationContext.xml 文件,而且只会加载一次,并且里面的那些对象已经创建好了。

第三步:配置监听器(在 web.xml 添加如下)

<!-- 配置WEB整合的监听器 -->
<listener>
    <!-- 服务器一启动,监听器这个类的方法就会执行,可以关联查看源码 --> 
    <!-- 配置该监听器是固定的,只需要每次粘贴过来就行。-->
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 加载方式:该监听器默认加载WEB-INF目录下的配置文件。-->
<!-- 我们提供配置方式,加载其他目录下配置文件,如src目录下的配置文件 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

第四步:编写 Servlet

public String save(){
    System.out.println("WEB层:保存客户...");
    ServletContext servletContext = ServletActionContext.getServletContext();
    // 需要使用WEB的工厂的方式
    WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    CustomerService cs = (CustomerService) context.getBean("customerService");
    cs.save();
    return NONE;
}

步骤小结:Spring框架整合WEB(不是最终的方案)

1. 创建JavaWEB项目,引入Spring的开发包。编写具体的类和方法。
    * 环境搭建好后,启动服务器来测试项目,发送每访问一次都会加载一次配置文件,这样效率会非常非常慢!!

2. 解决上面的问题
    * 将工厂创建好了以后放入到ServletContext域中.使用工厂的时候,从ServletContext中获得.
        * ServletContextListener:用来监听ServletContext对象的创建和销毁的监听器.
        * 当ServletContext对象创建的时候:创建工厂 , 将工厂存入到ServletContext

3. Spring整合Web项目
    * 引入spring-web-4.2.4.RELEASE.jar包
    * 配置监听器
         <!-- 配置Spring的核心监听器: -->
         <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
         </listener>
         <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
         </context-param>

4. 修改servlet的代码
    * 从ServletContext中获得工厂
    * 具体代码如下
        ServletContext servletContext = ServletActionContext.getServletContext();
        // 需要使用WEB的工厂的方式
        WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        CustomerService cs = (CustomerService) context.getBean("customerService");
        cs.save();  

参考:《2017黑马java基础班+就业班》视频

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值