Spring--day01

非本人总结的笔记，抄点笔记复习复习。感谢传智博客及黑马程序猿

感谢传智博客及黑马程序猿

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面向切面编程

IOC：控制反转

控制反转，之前调用一个类中的不是静态的方法，创建类的对象new类，再调用。现在使用Spring的IOC之后，不需要自己手动new创建对象，交给Spring进行管理。

Aop：面向切面编程

面向切面编程，在基本功能之上，可以添加一个额外功能，不添加额外功能，基本功能也可以运行。Aop底层原理动态代理

Spring是JavaEE的分层的一站式框架

针对JavaEE的三层结构分别有不同的方案。

JavaEE三层结构

Web层：springmvc

业务逻辑层：spring的ioc

持久化层：spring的jdbc模板

Spring的版本

Spring 3.x和4.x

Spring的好处

方便解耦，简化开发

Spring就是一个大工厂，可以将所有的对象创建和依赖关系维护，交给spring维护

AOP编程的支持

Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无需手动编程

方便程序的测试

Spring对Junit4支持，可以通过注解方便的测试Spring程序

方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持

降低JavaEE API的使用难度

Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

Spring的IOC入门

Spring的开发包

导入Spring的jar包

Core Container

Sping

导入的核心四个jar包，需要到下面文件夹里面找

文件夹

beans

core

context

expression

需要日志的输出，导入第三方的日志jar包

framework

log4j

最终使用六个jar包

jar包

IOC底层原理

IOC： 把对象的创建交给Spring管理，不需要手动创建对象

画图分析IOC实现原理

IOC底层原理

IOC的入门

第一步：导入jar包

jar包

第二步：创建配置文件

在src下面创建配置文件，名称没有固定的要求，一般是applicationContext.xml

引入约束，之前在Struts2或者Hibernate里面引入约束是dtd约束，在spring里面的配置文件映入的是schema约束，可以在文件中找到该约束

路径

schema约束文件

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!--id：给bean标签起名称，id值不能相同，要求id值里面不能包含特殊符号 
  class：要创建类的全路径
 -->
<!--第四步 在配置文件中配置哪个类进行对象创建-->
    <bean id="demo1" class="cn.itcast.ioc.TestIOCDemo1"></bean>
</beans>

第三步：创建类

创建类，在类里面创建方法

package cn.itcast.ioc;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestIOCDemo1 {
    public void run1() {
        System.out.println("run1................");
    }   
    public static void main(String[] args) {
        //创建TestIOCDemo1对象
        TestIOCDemo1 demo1 = new TestIOCDemo1();
        demo1.run1();
    }
    //第五步 写测试方法测试对象是否创建
    @Test
    public void iocDemo1() {
        //加载配置文件，创建对象
        //applicationContext.xml配置文件的名称
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据bean里面的id值获取创建的对象
        //"demo1"是配置文件中id的值
        TestIOCDemo1 ioc1 = (TestIOCDemo1) context.getBean("demo1");
        System.out.println(ioc1);
        ioc1.run1();
    }
}

第四步：对象创建

在配置文件中配置哪个类进行对象创建

第五步：测试

写测试方法测试对象是否创建

IOC(控制反转)和DI(依赖注入)区别

IOC(控制反转):把对象的创建权交个spring管理

DI(依赖注入)：在对象创建过程中，可以向对象所在的类里面的属性中设置值，这个过程称为依赖注入

依赖注入需要在控制反转的基础上完成

代码演示

第一步

首先在类创建一个属性，必须生成set方法

package cn.itcast.ioc;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestIOCDemo1 {

    private String username;
    public void setUsername(String username) {
        this.username = username;
    }

    public void run1() {
        System.out.println("run1................"+username);
    }
    
    public static void main(String[] args) {
        //创建TestIOCDemo1对象
        TestIOCDemo1 demo1 = new TestIOCDemo1();
        demo1.run1();
    }
    
    @Test
    public void iocDemo1() {
        //加载配置文件，创建对象
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据bean里面的id值获取创建的对象
        TestIOCDemo1 ioc1 = (TestIOCDemo1) context.getBean("demo1");
        System.out.println(ioc1);
        ioc1.run1();
    }
}

第二步

在配置创建对象的bean标签里面配置属性的注入

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!--========================= ioc的入门==============================-->
    <bean id="demo1" class="cn.itcast.ioc.TestIOCDemo1">
        <!-- 依赖注入 -->
        <property name="username" value="lucy"></property>
    </bean> 
</beans>

Spring的工厂类

ApplicationContext

     |----ClassPathXmlApplicationContext :解析类路径下的XML的.

     |----FileSystemXmlApplicationContext    :解析本地磁盘上的XML的.

UML图

BeanFactory和ApplicationContext都是Spring的工厂

BeanFactory是Spring工厂的老版本类：第一次调用getBean方法的时候实例化

ApplicationContext是Spring新版本的工厂类：在加载核心配置文件的时候，将所有的类实例化

Spring的bean管理(xml配置--非注解)

bean管理：创建对象的过程，创建对象的过程中设置属性值

Bean的实例化的三种方式(Spring创建对象的三种方式)

第一种：使用无参的构造方法创建

第一步：创建类

package cn.itcast.beanxml;

/**
 * 使用无参数的构造方法创建
 */
public class Bean1 {
    public Bean1() {
    }
    public void b1() {
        System.out.println("bean1................");
    }
}

第二步：在配置文件application.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="bean1" class="cn.itcast.beanxml.Bean1" 
scope="prototype"></bean>  
</beans>

第三步：创建测试类

package cn.itcast.beanxml;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean {
    
    @Test
    public void beanioc1() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean1 = (Bean1) context.getBean("bean1");
        System.out.println(bean1);
        bean1.b1();
    }
}

第二种：使用静态工厂创建

静态工厂：这个工厂类的里面的方法是static的，可以通过类名直接调用

实态工厂：这个工厂类的里面的方法不是static的，创建工厂的对象，再调用里面的方法

第一步：创建类

package cn.itcast.beanxml;
/**
 * 使用静态工厂创建对象
 */
public class Bean2 {

    public void b2() {
        System.out.println("b2...............");
    }
}

第二步：创建静态工厂类

package cn.itcast.beanxml;
/**
 * 使用静态工厂创建对象
 */
public class Bean2Factory {

    //静态方法
    public static Bean2 getBean2() {
        return new Bean2();
    }
}

第三步：在配置文件application.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的三种方式 ========-->
    
    <!-- 使用静态工厂创建对象 
        class: 工厂类的全路径
        factory-method: 工厂里面静态的方法
    -->
    <bean id="bean2" class="cn.itcast.beanxml.Bean2Factory" 
    factory-method="getBean2"></bean>
</beans>

第四步：创建测试类

package cn.itcast.beanxml;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean {
    
    @Test
    public void beanioc2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        System.out.println(bean2);
        bean2.b2();
    }
}

第三种：使用实例工厂创建

第一步：创建类

package cn.itcast.beanxml;
/**
 * 使用实例工厂创建对象
 */
public class Bean3 {

    public void b3() {
        System.out.println("b3................");
    }
}

第二步：创建静态工厂类

package cn.itcast.beanxml;

/**
 * 实例工厂创建
 */
public class Bean3Factory {

    public Bean3 getBean3() {
        return new Bean3();
    }
}

第三步：在配置文件application.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的三种方式 ========-->
    <!-- 使用实例工厂创建对象 -->
    <!-- 创建工厂的实例
         class: 工厂类的全路径
         factory-method: 工厂里面静态的方法
         factory-bean1上面id值一样
    -->
    <bean id="factory1" class="cn.itcast.beanxml.Bean3Factory"></bean>
    <bean name="bean3" factory-bean="factory1" factory-method="getBean3"></bean> 
</beans>

第四步：创建测试类

package cn.itcast.beanxml;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean {
    
    @Test
    public void beanioc3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean3 bean3 = (Bean3) context.getBean("bean3");
        System.out.println(bean3);
        bean3.b3();
    }
}

Spring的bean的常用配置

<bean>标签的id和name属性

id和name有什么区别？

id：使用xml中id约束，不可以出现特殊字符

name：出现特殊字符，如果使用了name没有id，那么name可以作为id使用

Spring整合Struts1: <bean name=”/login” class=””/>

<bean>上生命周期的配置

@Test
/**
* Bean的生命周期的相关配置:
*   * init-method
*   * destory-method :只能针对单例对象有效.必须在工厂关闭之后才会销毁对象.
*/
public void demo1(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    EmployeeService employeeService = (EmployeeService) applicationContex.getBean("employeeService");
    employeeService.save();
    applicationContext.close();
}

<bean>上的作用范围的配置

scope属性:

singleton :单例的.(默认)
prototype :多例的.
request :WEB项目中,创建一个对象,保存到request域中.
session :WEB项目中,创建一个对象,保存到session域中.

*globalsession :WEB项目中,特殊环境.分布式开发环境.如果没有分布式环境,相当于session.

Bean的生命周期

Spring的实例化bean过程中总共完成11步骤

instantiate bean对象实例化
populate properties 封装属性
如果Bean实现BeanNameAware执行setBeanName
如果Bean实现BeanFactoryAware或者ApplicationContextAware设置工厂setBeanFactory或者上下文对象setApplicationContext
如果Bean存在类实现BeanPostProcessor(后处理Bean)，执行postProcessBeforeInitialization
如果Bean实现InitializingBean执行afterPropertiesSet
调用<bean init-method="init"> 指定初始化方法init
如果存在类实现 BeanPostProcessor（处理Bean），执行postProcessAfterInitialization
执行业务处理
如果Bean实现 DisposableBean 执行 destroy
调用<beandestroy-method="customerDestroy"> 指定销毁方法 customerDestroy

第三步和第四步:主要让生成Bean了解Spring容器.

第五步和第八步:允许客户在Bean的生成过程中对Bean的实例进行增强.

BeanPostProcessor:工厂勾子.允许客户在生成类的过程中对类进行增强.

java里三种方式注入Bean属性

第一种：使用set方法注入

public class User() {
    private String username;
    public void setUsername(String username) {
        this.username = username; 
    }  
}

User user = new User();
user.setUsername("东方不败");

第二种：使用有参数的构造方法注入

public class Person{
    private int age;
    public Person(int age) {
        this.age = age;      
    }
}

Person p = new Person("岳不群");

第三种：使用接口注入

public interface Dao{
    public void run(String password);
}

public class UserDaoImpl implements Dao {
    private String password;
    public void run(String password) {
        this.passwordd = password;
    }
}

在Spring里面只是支持里面两种

第一种：使用set方法注入

第二种：使用有参数的构造注入

❤Spring注入bean属性的两种方式

Spring使用有参构造方法注入

第一步：创建类

创建类，声明属性，创建类有参数的构造方法

package cn.itcast.field;
/**
 * 使用有参数的构造方法注入属性
 */
public class ConstructorField {

    //声明属性
    private String username;
    private String password;
    //创建有参数构造方法
    public ConstructorField(String username, String password) {
        this.username = username;
        this.password = password;
    }
    
    public void demo1() {
        System.out.println("field1......"+username+" :: "+password);
    }
    
}

第二步：在配置文件里面配置

在配置文件里面进行配置，可以参数名称或者参数的位置配置值，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"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- ====================属性的注入方式 ========================-->
    <!-- 使用有参数构造方法注入属性 -->
    <bean id="field1" class="cn.itcast.field.ConstructorField">
        <!--配置有参数构造设置值 
            name: 属性名称
            value: 属性值
        -->
        <!--根据属性名称注入-->
        <constructor-arg name="username" value="mary"></constructor-arg>
        <constructor-arg name="password" value="520"></constructor-arg>
        
        <!--根据属性位置注入 
            第一个参数从 0 开始的
        -->
        <constructor-arg index="0" value="东方不败"></constructor-arg>
        <constructor-arg index="1" value="1314"></constructor-arg>
    </bean>     
</beans>

第三步：创建测试类

package cn.itcast.field;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestField {

@Test
    public void field1() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        ConstructorField field1 = (ConstructorField) context.getBean("field1");
        field1.demo1();
    }
}

Spring使用set方法注入

第一步：创建类

package cn.itcast.field;
/**
 * 使用属性的set方法注入
 */
public class SetField {

    //声明属性
    private String sname;
    private String address;
    //生成对应的set方法
    public void setSname(String sname) {
        this.sname = sname;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
    public void set1() {
        System.out.println("set.."+sname+" :: "+address);
    }
    
    public static void main(String[] args) {
        SetField set1 = new SetField();
        set1.setSname("aaa");
        set1.setAddress("bbb");
    }
}

第二步：在配置文件里面配置

在配置文件里面配置application.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"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- ====================属性的注入方式 ========================-->
    <!-- 使用属性的set方法注入值 -->
   <bean id="field2" class="cn.itcast.field.SetField">
        <!--
            name: 属性名称
            value: 设置的属性的值
            -->     
        <property name="sname" value="岳不群"></property>
        <property name="address" value="日本"></property>
    </bean> 
</beans>

第三步：创建测试类

package cn.itcast.field;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestField {

    @Test
    public void field2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SetField setField = (SetField) context.getBean("field2");
        System.out.println(setField);
        setField.set1();
    }
}

Spring复杂注入，使用<property>引入其他bean

第一步：创建两个类

package cn.itcast.field;

public class Car {
    /**
     * 创建car对象，注入两个属性值
     */
    private String cname;
    private String color;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setColor(String color) {
        this.color = color;
    }
    
    public void testcar() {
        System.out.println("car: "+cname+" :: "+color);
    }
}

package cn.itcast.field;

public class Person {

    //把car对象注入进来
    //把car作为当前person的一个属性
    private Car car;
    public void setCar(Car car) {
        this.car = car;
    }

    public void test1() {
        car.testcar();
    }
    
    /**
     * 传统方式
     */
    public void testperson() {
        Car car = new Car();
        car.setCname("aaa");
        car.setColor("red");
        car.testcar();
    }
    
    public static void main(String[] args) {
        Person p = new Person();
        p.testperson();
    }
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!-- 复杂的注入 -->
    <bean id="car" class="cn.itcast.field.Car">
        <property name="cname" value="奥拓"></property>
        <property name="color" value="蓝色"></property>
    </bean>
    <!--把car对象注入到person里面-->
    <bean id="person" class="cn.itcast.field.Person">
        
        <!--name: 属性名称  
            ref: 配置的car对象的bean的id值
        -->
        <property name="car" ref="car"></property>
    </bean> 
</beans>

第三步：创建测试类

package cn.itcast.field;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestField {

    @Test
    public void field3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = (Person) context.getBean("person");
        p.test1();
    }
}

Spring3.0的SpEL的属性注入(SpEL:Spring Expression Language)

SpEL语法：

语法：#{SpEL}

SpEL用法：

<bean id="carInfo" class="cn.itcast.spring.demo6.CarInfo">
</bean>
    
    <!-- SpEL的方式的属性注入 -->
<bean id="car2" class="cn.itcast.spring.demo6.Car2">
    <property name="name" value="#{carInfo.carName}"/>
    <property name="price" value="#{carInfo.calculatorPrice()}"/>
</bean>

<bean id="employee" class="cn.itcast.spring.demo6.Employee">
    <property name="name" value="涛哥"/>
    <property name="car2" value="#{car2}"/>
</bean>

Spring的2.5支持p名称空间注入属性(会用)

为了简化XML文件配置，Spring从2.5开始引入一个新的p名称空间

第一步：创建类

创建类，声明属性，生成set方法

package cn.itcast.field;

public class Car {
    /**
     * 创建car对象，注入两个属性值
     */
    private String cname;
    private String color;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setColor(String color) {
        this.color = color;
    }
    
    public void testcar() {
        System.out.println("car: "+cname+" :: "+color);
    }
}

第二步：在配置文件里面进行配置

声明空间和配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       <!-- 声明名称空间 p -->
       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">
    <!-- p名称空间注入 -->
     <bean id="car" class="cn.itcast.field.Car" p:cname="宝马" p:color="绿色"></bean> 
</beans>

第三步：创建测试类

package cn.itcast.field;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestField {

    @Test
    public void field4() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Car car = (Car) context.getBean("car");
        car.testcar();
    }
}

数组集合属性注入

数组属性注入

在一个类中，有一个属性，属性类型是数组形式，向数组的属性里面设置值

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Arrays;

/**
 * 数组属性的注入
 */
public class ArrayField {

    //声明数组属性
    private String[] arr;
    //set方法
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    
    public void testarray() {
        System.out.println(Arrays.toString(arr));
    }
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- ===================数组和集合属性的注入============= -->
    <!-- 数组属性的注入 -->
    <bean id="arrayField" class="cn.itcast.arraycollection.ArrayField">
        <property name="arr">
            <list>
                <value>小明</value>
                <value>小丽</value>
                <value>小兰</value>
            </list>
        </property>
    </bean>
</beans>

第三步：创建测试类

package cn.itcast.arraycollection;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestArrayCollection {
    
    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ArrayField array = (ArrayField) context.getBean("arrayField");
        array.testarray();
    }
}

list集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.List;

/**
 * list集合属性的注入
 */
public class ListField {

    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
    
    public void testlist() {
        for(String value:list) {
            System.out.println("********* "+value);     
        }
    }   
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- ===================数组和集合属性的注入============= -->
    <!-- list类型属性注入 -->
    <bean id="listField" class="cn.itcast.arraycollection.ListField">
        <property name="list">
            <list>
                <value>小糖</value>
                <value>小成</value>
                <value>小飞</value>
            </list>
        </property>
    </bean>
</beans>

第三步：创建测试类

package cn.itcast.arraycollection;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestArrayCollection {
    
    @Test
    public void demo2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ListField list = (ListField) context.getBean("listField");
        list.testlist();
    }
}

Set集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Set;

/**
 * set集合属性的注入
 */
public class SetField {

    private Set<String> set;
    public void setSet(Set<String> set) {
        this.set = set;
    }
    
    public void testset() {
        for(String value : set) {
            System.out.println("===== "+value);
        }
    }
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- ===================数组和集合属性的注入============= -->
    <!-- set类型属性注入 -->
    <bean id="setField" class="cn.itcast.arraycollection.SetField">
        <property name="set">
            <set>
                <value>小温</value>
                <value>小奥</value>
            </set>
        </property>
    </bean>
</beans>

第三步：创建测试类

package cn.itcast.arraycollection;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestArrayCollection {
    
    @Test
    public void demo3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SetField set = (SetField) context.getBean("setField");
        set.testset();
    }
}

Map集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Map;

/**
 * map集合属性的注入
 */
public class MapField {

    private Map<String,Integer> map;
    public void setMap(Map<String, Integer> map) {
        this.map = map;
    }

    public void testmap() {
        System.out.println(map);
    }
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- ===================数组和集合属性的注入============= -->
    <!-- map类型属性注入 -->
    <bean id="mapField" class="cn.itcast.arraycollection.MapField">
        <property name="map">
            <map>
                <entry key="age" value="20"></entry>
                <entry key="price" value="99"></entry>
            </map>
        </property>
    </bean>
</beans>

第三步：创建测试类

package cn.itcast.arraycollection;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestArrayCollection {
    
    @Test
    public void demo4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MapField mapField = (MapField) context.getBean("mapField");
        mapField.testmap();
    }
}

Properties属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Properties;

/**
 * Properties类型属性的注入
 */
public class PropertiesField {

    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void testproperties() {
        System.out.println(properties);
    }
}

第二步：在配置文件里面配置

<?xml version="1.0" encoding="UTF-8"?>
<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">
<!-- ===================数组和集合属性的注入============= -->
    <!-- map类型属性注入 -->
    <bean id="propertiesField" class="cn.itcast.arraycollection.PropertiesField">
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="url">localhost</prop>
            </props>
        </property>
    </bean>
</beans>

第三步：创建测试类

package cn.itcast.arraycollection;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestArrayCollection {
    
    @Test
    public void demo5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        PropertiesField propertiesField = (PropertiesField) context.getBean("propertiesField");
        propertiesField.testproperties();
    }
}

Spring的bean管理(注解配置)

回顾：注解，代码里面特殊标记，写法@注解名称(值)，注解使用在类上面，方法上面，属性上面

入门案例

第一步：在配置文件里面进行配置

<?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: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.引入约束内容xmlns:context    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
          -->
    <!-- 2.配置spring扫描注解 
        context:component-scan ： 可以扫描到类上面和属性上面的和方法上面的注解
        context:annotation-config： 可以扫描只是属性上面的注解
    -->
    <context:component-scan base-package="cn.itcast"></context:component-scan>
    
    <!-- <context:annotation-config></context:annotation-config> -->
</beans>

第二步：创建类

package cn.itcast.annotation;

import org.springframework.stereotype.Controller;
//类似于之前xml配置文件
  <bean id="hello" class="cn.itcast.ioc.Hello">
@Controller(value="hello")
public class Hello {

    public void say() {
        System.out.println("hello annotation........");
    }
}

第三步：创建测试类

package cn.itcast.annotation;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAnno {
    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext1.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
        hello.say();
    }
}

Bean管理常用的注解

第一部分注解：用来生成类对象

注解	功能
@Component	生成类对象
@Repository	用于对Dao实现类进行标注
@Service	用于对Service实现类进行标注
@Controller	用于对Controller实现类进行标注

这四个注解的功能是一样的，都是用来生成类的对象，可以使用在类上面

@Controller(value="hello")
public class Hello{
  
}

第二部分注解：做注入的操作，把类对象注入到另一个类中

在此类中声明要注入的对象所在类，作为一个属性，不需要set方法

使用@Autowried进行自动注入(自动装配)，根据类对象名称，找到类的对象

@Autowried
private UserDao userDao;

使用@Resource(name="值")实现指定哪个对象注入

@Component(value="userDao")
public class UserDao{
  
}

@Resource(name="userDao")
private UserDao userDao;

Resource里面的name值和@Component里面的value值一样

综合练习

创建Service类，调用两个Dao里面的方法，在Service里面得到两个dao的对象

第一步：创建类

package cn.itcast.lianxi;

import javax.annotation.Resource;

public class PersonService {
    //属性的注入使用注解方式完成
    @Resource(name="productDao")
    private ProductDao productDao;
    
    @Resource(name="ordersDao")
    private OrdersDao ordersDao;
    
    public void testservice() {
        System.out.println("service执行了.......");
        productDao.testproduct();
        ordersDao.testorder();
    }
}

package cn.itcast.lianxi;

public class ProductDao {

    public void testproduct() {
        System.out.println("productdao执行了...........");
    }
}

package cn.itcast.lianxi;

public class OrdersDao {

    public void testorder() {
        System.out.println("orderdao执行了...............");
    }
}

第二步：在配置文件里面进行配置

<?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: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">
    
    <!-- 配置spring扫描注解 
        context:component-scan ： 可以扫描到类上面和属性上面的和方法上面的注解
        context:annotation-config： 可以扫描只是属性上面的注解
    -->
    <context:component-scan base-package="cn.itcast"></context:component-scan>
    
    <!-- <context:annotation-config></context:annotation-config> -->
    
    <!-- 配置productdao和ordersdao对象 -->
    <bean id="productDao" class="cn.itcast.lianxi.ProductDao"></bean>
    <bean id="ordersDao" class="cn.itcast.lianxi.OrdersDao"></bean>
    <!-- service对象 -->
    <bean id="personService" class="cn.itcast.lianxi.PersonService"></bean>
</beans>

第三步：创建测试类

package cn.itcast.lianxi;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAnno {

    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext1.xml");
        PersonService servcie = (PersonService) context.getBean("personService");
        servcie.testservice();
    }
}

最后编辑于：2017.12.05 23:18:38

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 200,045评论 5赞 468
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 84,114评论 2赞 377
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 147,120评论 0赞 332
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 53,902评论 1赞 272
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 62,828评论 5赞 360
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,132评论 1赞 277
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,590评论 3赞 390
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,258评论 0赞 254
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,408评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,335评论 2赞 317
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,385评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,068评论 3赞 315
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,660评论 3赞 303
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,747评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,967评论 1赞 255
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,406评论 2赞 346
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 41,970评论 2赞 341