码迷，mamicode.com
首页 > 编程语言 > 详细

Spring的概述

时间：2018-04-04 20:51:45      阅读：202      评论：0      收藏：0      [点我收藏+]

标签：迪米特法则   获取   factory   factor   java编程思想   整合   常用   close   ase   

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(一站式)轻量级开源框架。

为什么说Spring是一个一站式的轻量级开源框架呢？EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。

  • WEB层：SpringMVC
  • 业务层：Spring的IoC
  • 持久层：Spring的JDBCTemplate(Spring的JDBC模板，ORM模板用于整合其他的持久层框架)

从上面的简要介绍中，我们要知道Spring的核心有两部分：

  • IoC：控制反转。 
    举例来说，在之前的操作中，比方说有一个类，我们想要调用类里面的方法(不是静态方法)，就要创建类的对象，使用对象调用方法实现。对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的。
  • AOP：面向切面编程。 
    之前，讲Struts2框架的拦截器时，我们就已稍微讲了一下，在Spring学习过程中，我们会着重来讲它。但是本文并不会过多阐述它，下文再讲。

为什么Spring

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

Spring的版本

我这儿使用的Spring的版本是spring-framework-4.2.4.RELEASE。

Spring的入门案例

IOC的底层实现原理

IOC：Inversion of Control，控制反转。指的是对象的创建权反转(交给)给Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了。对象创建的控制权不是“使用者”，而是“框架”或者“容器”。 
用更通俗的话来说，IOC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。其底层实现原理是XML配置文件+SAX解析+工厂设计模式。 
就拿持久层(也即dao(data access object，数据访问对象)层)的开发来说，官方推荐做法是先创建一个接口，然后再创建接口对应的实现类。 
先创建一个Userdao接口

public interface UserDao {
    public void add();
}

 

再创建Userdao接口的UserDaoImpl实现类

public class UserDaoImpl implements UserDao {
    public void add() {
        balabala......
    }
}

 

接着我们在service层调用dao层，核心代码如下：

// 接口 实例变量 = new 实现类
UserDao dao = new UserDaoImpl();
dao.add();

 

可发现缺点：service层和dao层耦合度太高了。解决方法是使用工厂模式进行解耦合操作。 
创建一个工厂类，在工厂类中提供一个方法，返回实现类的对象。

public class Factory {
    // 提供返回实现类对象的方法
    public static UserDao getUserDaoImpl() {
        return new UserDaoImpl();
    }
}

 

然后在service层调用dao层的核心代码就变为：

UserDao dao = Factory.getUserDaoImpl();
dao.add();

 

如若这样做，会发现又产生了一个缺点：service层和工厂类又耦合了。所以使用工厂模式进行解耦合也只是一种权宜之计。下面我就来简单讲讲Spring IOC的底层实现原理：

    • 配置文件中可能会有如下配置信息：

      <bean id="userDaoImpl" class="cn.itcast.dao.impl.UserDaoImpl" />

    • 也是要创建一个工厂类，在工厂类中提供一个返回实现类对象的方法，但并不是直接new实现类，而是使用SAX解析配置文件，根据标签bean中的id属性值得到对应的class属性值，使用反射创建实现类对象。

      public class Factory {
    public static UserDao getUserDaoImpl() {
        // 1.使用SAX解析得到配置文件内容
        // 直接根据id值userDaoImpl得到class属性值
        String classvalue = "class属性值";
        // 2.使用反射得到对象
        Class clazz = Class.forName(classvalue);
        UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
        return userDaoImpl;
    }
}

 

面向对象设计的七大原则

这里我稍微讲一下面向对象设计的七大原则，不必强记，重在理解。

  1. 单一职责原则（Single Responsibility Principle）：每一个类应该专注于做一件事情。
  2. 里氏替换原则（Liskov Substitution Principle）：超类存在的地方，子类是可以替换的。
  3. 依赖倒置原则（Dependence Inversion Principle）：实现尽量依赖抽象，不依赖具体实现。
  4. 接口隔离原则（Interface Segregation Principle）：应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
  5. 迪米特法则（Law Of Demeter）：又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。
  6. 开闭原则（Open Close Principle）：面向扩展开放，面向修改关闭。
  7. 组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）：尽量使用组合/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象。

Spring的IOC入门

步骤一：下载Spring的开发包

Spring的官网是http://spring.io。Spring的开发包的下载地址是http://repo.springsource.org/libs-release-local/org/springframework/spring，上面说过，我下载的是spring-framework-4.2.4.RELEASE。解压缩之后，可发现Spring开发包的目录结构如下： 
技术分享图片

  • docs：API和开发规范
  • libs：Jar包和源码
  • schema：约束

步骤二：创建Web项目，引入Spring的开发包

从下图可知： 
技术分享图片 
由于我们只是初次入门Spring，所以也只是使用Spring的基本功能，所以需要使用到下面的这4个Jar包： 
技术分享图片 
除此之外，还要导入Spring支持的日志Jar包： 
技术分享图片

步骤三：编写相关的类，在类中创建方法

在src目录下创建一个cn.itcast.ioc包，并在该包下创建一个User类。

public class User {
    public void add() {
        System.out.println("add.................");
    }
}

步骤三：创建Spring配置文件

注意：Spring配置文件的名称和位置没有固定要求，一般建议把该文件放到src下面，名称可随便写，官方建议写成applicationContext.xml。但我觉得这个文件名称太长了，所以决定写为bean1.xml。然后我们还需要在配置文件中引入约束，Spring学习阶段的约束是schema约束。那么问题来了，这个约束又该怎么写呢？可参考docs\spring-framework-reference\html目录下的xsd-configuration.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"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="foo" class="x.y.Foo">
        <meta key="cacheName" value="foo"/>
        <property name="name" value="Rick"/>
    </bean>

</beans>

然后将其复制黏贴到配置文件bean1.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">

</beans>

步骤四：在配置文件中配置对象的创建

<!-- 1.配置user对象的创建 --> 
<bean id="user" class="cn.itcast.ioc.User"></bean>

步骤五：编写测试程序

我们要在Spring中写代码来实现获取bean1.xml文件中配置的对象（该段代码不要求重点掌握，只是用在测试中而已）。这段代码主要用来解析Spring配置文件得到对象，但这个过程不需要我们写代码实现，Spring封装了一个对象帮我们进行了这些操作，这个对象叫ApplicationContext，它就能实现这个功能。 
在cn.itcast.ioc包下创建一个TestIOC单元测试类，如下：

public class TestIOC {

    // 得到配置的user对象
    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml"); // classpath：类路径，src目录下的文件最终要编译到类路径下
        // 2.根据配置文件的id得到user对象
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
    }
}

 

注意：classpath为类路径，src目录下的文件最终要编译到类路径下。

Spring的bean管理

通俗一点说，Spring的bean管理即指创建对象时不需要new操作代码实现，而是交给Spring进行配置完成。 
Spring进行bean管理有两种方式：

  1. 使用配置文件方式实现
  2. 使用注解方式实现

本文将重点放在第一种方式上，后一种方式后面会讲。

Spring实例化bean的三种方式

使用无参构造（重点）

创建对象时候，调用类里面的无参数的构造方法实现。那么Spring配置文件中又该怎样写呢？基本类似于如下写法：

<!-- 1.配置user对象的创建 --> 
<bean id="user" class="cn.itcast.ioc.User"></bean>

使用静态工厂（了解）

创建一个工厂类，在工厂类中提供一个静态的方法，这个方法返回类的对象；调用工厂类的方法时候，直接使用类名.方法名称即可以调用。下面举例来说明。 
在src目录下创建一个cn.itcast.bean包，并在该包下创建一个Bean1类。

public class Bean1 {

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

}

然后在该包下创建一个Bean1Factory工厂类。

public class Bean1Factory {

    // 静态方法
    public static Bean1 getBean1() {
        return new Bean1();
    }

}

接着Spring配置文件中应向下面这样配置：

<!-- 2.使用静态工厂创建对象 -->
<bean id="bean1" class="cn.itcast.bean.Bean1Factory" factory-method="getBean1"></bean>

最后在该包下创建一个TestIOC单元测试类。

public class TestIOC {

    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2.根据配置文件的id得到user对象
        Bean1 bean1 = (Bean1) context.getBean("bean1");
        System.out.println(bean1);
    }
}

使用实例工厂（了解）

创建一个工厂类，在工厂类里面提供一个普通的方法，这个方法返回类对象；调用工厂类的方法时候，创建工厂类对象，使用对象调用方法即可。下面也举例来说明。 
在src目录下的cn.itcast.bean包下创建一个Bean2类。

public class Bean2 {

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

}

然后在该包下创建一个Bean2Factory工厂类。

public class Bean2Factory {

    public Bean2 getBean2() {
        return new Bean2();
    }

}

接着Spring配置文件中应向下面这样配置：

<!-- 3.使用实例工厂创建对象 -->
<!-- 3.1先创建工厂对象 -->
<bean id="bean2Factory" class="cn.itcast.bean.Bean2Factory"></bean>
<!-- 3.2再使用工厂对象创建bean2对象 -->
<bean id="bean2" factory-bean="bean2Factory" factory-method="getBean2"></bean>

最后将TestIOC单元测试类的代码修改为：

public class TestIOC {

    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2.根据配置文件的id得到user对象
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        System.out.println(bean2);
    }
}

Spring配置文件中bean标签常用的属性

Spring配置文件中bean标签常用的属性有以下四种：

  1. id属性：根据id属性值得到配置对象。 
    在Spring配置文件中会有多个bean标签，但它们的id属性值是不能相同的。Bean起名字时，在约束中采用的是ID约束——唯一，而且名字必须以字母开始，可以使用字母、数字、连字符、下划线、句号、冒号等，但id属性值不能有特殊符号。
  2. class属性：要创建对象的类的全路径。

  3. scope属性：bean的作用范围。 
    scope属性共有以下5个属性：

    • singleton：创建的对象是单例的，也是scope属性的默认值。 
      下面我来举例说明它。将TestIOC单元测试类的代码修改为：

      public class TestIOC {

    // 得到配置的user对象
    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2.根据配置文件的id得到user对象
        User user1 = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");
        System.out.println(user1);
        System.out.println(user2);
    }
}
    • 单元测试以上方法，一切就尽在不言中。其实，此时Spring配置文件中有关如下bean的配置：
    • <bean id="user" class="cn.itcast.ioc.User"></bean>

    • 就相当于：

      <bean id="user" class="cn.itcast.ioc.User" scope="singleton"></bean>

    • prototype：创建的对象是多实例的。 
      也可举例来说明它。将Spring配置文件中有关如下bean的配置：

      <bean id="user" class="cn.itcast.ioc.User"></bean>

    • 修改为：

      <bean id="user" class="cn.itcast.ioc.User" scope="prototype"></bean>

    • 测试单元测试类的方法就能明白了。

    • globalSession：用在单点登录(即SSO，single sign on)上。
  4. name属性：name属性的功能和id属性是一样的。name属性和id属性区别是：在id属性值里面不能有特殊符号，在name属性值里面可以添加特殊符号。

bean的生命周期的配置

通过配置<bean>标签上的init-method作为bean的初始化的时候执行的方法，配置destroy-method作为bean的销毁的时候执行的方法。销毁方法想要执行，需要是单例创建的Bean而且在工厂关闭的时候，Bean才会被销毁。

Spring中Bean的属性注入

实际上，有关Bean的属性注入共有三种方式，下面我分别加以简单的说明：

    1. set方法注入 
      用代码可表示如下：

      public class Book {

    private String bookname;

    public void setBookname(String bookname) {
        this.bookname = bookname;
    }

}

Book book = new Book();
book.setBookName("Java编程思想");

    2. 有参数构造注入 
      用代码可表示如下：

      public class Book {

    private String bookname;

    public Book(String bookname) {
        this.bookname = bookname;
    }

}

Book book = new Book("代码大全");

 

    1. 接口注入 
      先编写一个接口：

      public interface Dao {
    public void add(String name);
}

    2. 再编写这个接口的实现类：

      public class DaoImpl implements Dao {
    private String name;

    public void add(String name) {
        this.name = name;
    }
}

 

但在Spring框架里面，只支持前两种方式，即set方法注入和有参数构造注入。下面我来举例分别演示。

构造方法的方式注入属性

在src目录下创建一个cn.itcast.property包，并在该包下编写一个Book实体类。

public class Book {

    private String bookname;

    public Book(String bookname) {
        this.bookname = bookname;
    }

    public void testBook() {
        System.out.println("book.............." + bookname);
    }

}

接着在Spring配置文件中对以上JavaBean添加如下配置：

<!-- 4.使用有参数的构造注入属性 -->
<bean id="book" class="cn.itcast.property.Book">
    <!-- 使用标签，name：为属性的名字；value：为属性的值 -->
    <constructor-arg name="bookname" value="beautifulMan_美美侠"></constructor-arg>
</bean>

 

最后在该包下编写一个TestIOC单元测试类：

public class TestIOC {

    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");

        Book book = (Book) context.getBean("book");
        book.testBook();
    }
}

 

自己自行测试去吧！

set方法的方式注入属性

我们同样在cn.itcast.property包下编写一个Person实体类，在类中定义属性，并生成set方法。

public class Person {

    // 1.定义一个属性
    private String username;

    // 2.生成这个属性的set方法
    public void setUsername(String username) {
        this.username = username;
    }

    public void testperson() {
        System.out.println("person.............." + username);
    }

}

然后在Spring配置文件中，使用bean标签创建对象，在bean标签里面使用property标签注入属性。即在Spring配置文件中对以上JavaBean添加如下配置，

<!-- 5.使用set方法进行注入属性 -->
<bean id="person" class="cn.itcast.property.Person">
    <!--
        使用property标签注入属性值
        name：类属性名称
        value属性：往属性中注入的值
    -->
    <property name="username" value="李阿昀"></property>
</bean>

 

最后将TestIOC单元测试类的代码修改为：

public class TestIOC {

    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");

        Person person = (Person)context.getBean("person");
        person.testperson();
    }
}

 

自己自行测试去吧！

Spring的属性注入：对象类型的注入

在实际开发中，我们要提交表单到action里面去，然后在action里面调用service层的方法，接着在service层里面调用dao层的方法。在这里，我假设在service层里面调用dao层的方法，所以需要在servcie层里面创建dao层的对象实现调用。 
先在src目录下创建一个cn.itcast.dao包，并在该包下编写一个UserDao类。

public class UserDao {

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

 

然后在src目录下再创建一个cn.itcast.service包，并在该包下编写一个UserService类。

public class UserService {

    public void add() {
        System.out.println("service.........");
        // 调用dao
        balabala......
    }

}

 

如果我们使用最原始的方式在service层里面调用dao层的方法，那么UserService类中add()方法应这样写：

public void add() {
    System.out.println("service.........");
    // 原始方式，调用dao
    UserDao dao = new UserDao();
    dao.add();
}

 

在Spring里面，我们就应该这么玩了。我们的最终目的是在service层里面得到dao层对象。所以步骤为：

    1. 第一步，让dao作为service的一个属性。

      // 1.让dao作为service的一个属性
private UserDao userDao;
      • 1
      • 2

    2. 第二步，生成dao属性的set方法。

      // 2.生成dao属性的set方法
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

    3. 这时，UserService类的代码就变成：

      public class UserService {

    // 1.让dao作为service的一个属性
    private UserDao userDao;

    // 2.生成dao属性的set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service.........");
        userDao.add();
    }

}

 

  1. 在Spring配置文件中进行配置和注入。

    <!-- 6.注入对象的属性 -->
<!-- 6.1先创建dao对象 -->
<bean id="userDao" class="cn.itcast.dao.UserDao"></bean>
<!-- 6.2再创建service对象    -->
<bean id="userService" class="cn.itcast.service.UserService">
    <!-- 在servcie里面注入userDao属性
        name属性：service对象里面的userDao属性的名称
        注入dao对象，不能写value属性，要写ref属性：dao配置的bean的id值
    -->
    <property name="userDao" ref="userDao"></property>
</bean>

名称空间p的属性注入方式——Spring2.x版本后提供的方式

在src目录下创建一个cn.itcast.propertydemo包，并在该包下编写一个Orders实体类。

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    public void testorders() {
        System.out.println("orders................" + oname);
    }
}

接下来我们需要在Spring核心配置文件中的schema约束位置定义p名称空间。

xmlns:p="http://www.springframework.org/schema/p"
  • 1

紧接着，我们需要在Spring核心配置文件中添加如下配置：

<!-- 7.p(property，属性)名称空间的注入 -->
<bean id="orders" class="cn.itcast.propertydemo.Orders" p:oname="去你妈的！！！"></bean>
  • 1
  • 2

最后将cn.itcast.property包下的TestIOC单元测试类的代码修改为：

public class TestIOC {
    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");

        Orders orders = (Orders)context.getBean("orders");
        orders.testorders();
    }
}

 

测试即可。 
结论——使用p名称空间：

  • 普通属性：p:属性名称=”…”
  • 对象类型的属性：p:属性名称-ref=”…”

注入复杂属性

注入数组类型的属性

将cn.itcast.propertydemo包下的Orders类的代码修改为：

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    // 1.数组类型的属性
    private String[] arrays;
    public void setArrays(String[] arrays) {
        this.arrays = arrays;
    }

    public void testorders() {
        // System.out.println("orders................" + oname);
        System.out.println("数组：" + Arrays.toString(arrays));
    }
}

 

然后需要在Spring核心配置文件中添加如下配置：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- 数组类型 -->
    <property name="arrays"> <!-- 注入属性 -->
        <list>
            <value>叶子</value>
            <value>liayun</value>
            <value>杰哥</value>
        </list>
    </property>
</bean>

 

最后将cn.itcast.property包下的TestIOC单元测试类的代码修改为：

public class TestIOC {
    @Test
    public void demo1() {
        // 1.加载Spring配置文件，把配置文件中的对象进行创建
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("bean1.xml");
        Orders orders = (Orders)context.getBean("orders");
        orders.testorders();
    }
}

测试即可。

注入List集合类型的属性

将cn.itcast.propertydemo包下的Orders类的代码修改为：

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    // 2.list类型的属性
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }

    public void testorders() {
        // System.out.println("orders................" + oname);
        System.out.println("list：" + list);
    }
}

然后需要在Spring核心配置文件中添加如下配置：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- list类型 -->
    <property name="list">
        <list>
            <value>叶子</value>
            <value>李昀玲</value>
            <value>杰哥</value>
        </list>
    </property>
</bean>
  •  

cn.itcast.property包下的TestIOC单元测试类的代码勿须修改，直接测试即可。

注入Set集合类型的属性

将cn.itcast.propertydemo包下的Orders类的代码修改为：

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    // 3.set类型的属性
    private Set<String> keyset;
    public void setKeyset(Set<String> keyset) {
        this.keyset = keyset;
    }

    public void testorders() {
        // System.out.println("orders................" + oname);
        System.out.println("set：" + keyset);
    }
}

然后需要在Spring核心配置文件中添加如下配置：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- set类型 -->
    <property name="keyset">
        <set>
            <value>蝙蝠侠</value>
            <value>钢铁侠</value>
            <value>美美侠</value>
        </set>
    </property>
</bean>
  •  

其实，以上配置也可以写为：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- set类型 -->
    <property name="keyset">
        <list>
            <value>蝙蝠侠</value>
            <value>钢铁侠</value>
            <value>美美侠</value>
        </list>
    </property>
</bean>
  •  

cn.itcast.property包下的TestIOC单元测试类的代码勿须修改，直接测试即可。

注入Map集合类型的属性

将cn.itcast.propertydemo包下的Orders类的代码修改为：

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    // 4.map类型
    private Map<String, String> map;
    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void testorders() {
        // System.out.println("orders................" + oname);
        System.out.println("map：" + map);
    }
}
  •  

然后需要在Spring核心配置文件中添加如下配置：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- map类型 -->
    <property name="map">
        <map>
            <entry key="username" value="潘金莲"></entry>
            <entry key="password" value="1314"></entry>
            <entry key="address" value="明初"></entry>
        </map>
    </property>
</bean>
  •  

cn.itcast.property包下的TestIOC单元测试类的代码勿须修改，直接测试即可。

注入Properties类型的属性

将cn.itcast.propertydemo包下的Orders类的代码修改为：

public class Orders {

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
    }

    // 5.properties
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void testorders() {
        // System.out.println("orders................" + oname);
        System.out.println("properties：" + properties);
    }
}
  •  

然后需要在Spring核心配置文件中添加如下配置：

<bean id="orders" class="cn.itcast.propertydemo.Orders"> <!-- 创建对象 -->
    <!-- properties类型 -->
    <property name="properties">
        <props>
            <prop key="name">宫本一郎</prop>
            <prop key="address">日本</prop>
        </props>
    </property>
</bean>
  •  

cn.itcast.property包下的TestIOC单元测试类的代码勿须修改，直接测试即可。

IoC和DI的区别

  • IoC：控制反转，即把对象的创建交给Spring进行管理。所以Spring IoC容器是用来创建对象，管理依赖关系的。
  • DI(Dependency Injection)：依赖注入，即在创建对象的过程中，向类里面的属性中设置值。
  • IoC和DI的关系：依赖注入不能单独存在，须在控制反转基础之上完成，用更通俗点的话来说，就是注入类里面的属性值，不能直接注入，须创建类的对象再完成注入。

Spring中的工厂

ApplicationContext

ApplicationContext接口有两个实现类，如下图： 
技术分享图片

  • ClassPathXmlApplicationContext：加载的是类路径下的Spring配置文件
  • FileSystemXmlApplicationContext：加载的是本地磁盘下的Spring配置文件

BeanFactory

下面应该是BeanFactory类的继承体系图吧！ 
技术分享图片 
稍微了解一下就好，这个类在实际开发中我们并不需要用到。

ApplicationContext和BeanFactory的区别

虽然使用这两个对象都可以加载Spring的配置文件，并创建配置文件中的对象。但他俩还是有区别的，最主要的区别是：

  • 使用applicationContext操作时，可把Spring里面的配置文件中的对象都进行创建。
  • 使用BeanFactory对象操作时，在调用getBean方法的时候进行对象的创建。

Spring整合Web项目的底层原理

在实际的开发中，我们一般会使用SSH(即Struts2、Spring、Hibernate)进行开发，然后创建Spring的配置文件，使用applicationContext对象加载配置文件，继而创建对象。在真正的开发中，我们一般不会直接写applicationContext代码加载配置文件。

Spring整合Web项目的思想

在服务器启动的时候，加载Spring配置文件，并创建对象。

Spring整合Web项目的底层原理

Spring整合Web项目用到以下两个技术：

  • 使用ServletContext对象(在服务器启动时创建)
  • 使用监听器

在服务器启动的时候，每个项目都会创建一个ServletContext对象，而且每个项目只有一个ServletContext对象。在ServletContext对象创建的时候，使用监听器可以监听到其创建。当我们监听到ServletContext对象创建时，Spring就会帮我们做一件事情——加载Spring配置文件，并把配置文件中的对象进行创建，对象创建之后，放到ServletContext域里面去，最终我们要使用创建的对象，可从ServletContext域里面获取出来

Spring的概述

标签：迪米特法则   获取   factory   factor   java编程思想   整合   常用   close   ase   

原文地址：https://www.cnblogs.com/holyday/p/8718249.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！