Spring初学快速入门 - Spring教程™ https://www.yiibai.com/spring/spring-tutorial-for-beginners.html#

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yiibai</groupId>
    <artifactId>HelloSpring</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>

        <!-- Spring Core -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- Spring Context -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

    </dependencies>
</project>

D:\worksp\spring\src\main\resources\beans.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="springHelloWorld" class="com.yiibai.tutorial.spring.helloworld.impl.SpringHelloWorld"></bean>
    <bean id="strutsHelloWorld" class="com.yiibai.tutorial.spring.helloworld.impl.StrutsHelloWorld"></bean>
    <bean id="helloWorldService" class="com.yiibai.tutorial.spring.helloworld.HelloWorldService">
        <!--<property name="helloWorld" ref="springHelloWorld"/>-->
        <property name="helloWorld" ref="strutsHelloWorld"/>
    </bean>
</beans>

└── spring

    ├── pom.xml

    ├── spring.iml

    ├── src

    │   ├── main

    │   │   ├── java

    │   │   │   └── com

    │   │   │       └── yiibai

    │   │   │           └── tutorial

    │   │   │               └── spring

    │   │   │                   ├── HelloProgram.java

    │   │   │                   └── helloworld

    │   │   │                       ├── HelloWorld.java

    │   │   │                       ├── HelloWorldService.java

    │   │   │                       └── impl

    │   │   │                           ├── SpringHelloWorld.java

    │   │   │                           └── StrutsHelloWorld.java

    │   │   └── resources

    │   │       └── beans.xml

    │   └── test

    │       └── java

    └── target

        ├── classes

        │   ├── beans.xml

        │   └── com

        │       └── yiibai

        │           └── tutorial

        │               └── spring

        │                   ├── HelloProgram.class

        │                   └── helloworld

        │                       ├── HelloWorld.class

        │                       ├── HelloWorldService.class

        │                       └── impl

        │                           ├── SpringHelloWorld.class

        │                           └── StrutsHelloWorld.class

        └── generated-sources

            └── annotations

D:\worksp\spring\src\main\java\com\yiibai\tutorial\spring\helloworld\impl\SpringHelloWorld.java

package com.yiibai.tutorial.spring.helloworld.impl;

import com.yiibai.tutorial.spring.helloworld.HelloWorld;

public class SpringHelloWorld implements HelloWorld {
    @Override
    public void sayHello(){
        System.out.println("Spring Say Hello");
    }
}

D:\worksp\spring\src\main\java\com\yiibai\tutorial\spring\helloworld\impl\StrutsHelloWorld.java

package com.yiibai.tutorial.spring.helloworld.impl;

import com.yiibai.tutorial.spring.helloworld.HelloWorld;

public class StrutsHelloWorld implements HelloWorld {
    @Override
    public void sayHello() {
        System.out.println("Struts Say Hello!");
    }
}

D:\worksp\spring\src\main\java\com\yiibai\tutorial\spring\helloworld\HelloWorld.java

package com.yiibai.tutorial.spring.helloworld;

public interface HelloWorld {
    public void sayHello();
}

D:\worksp\spring\src\main\java\com\yiibai\tutorial\spring\helloworld\HelloWorldService.java

package com.yiibai.tutorial.spring.helloworld;

public class HelloWorldService {
    private HelloWorld helloWorld;

    public HelloWorldService() {

    }

    public void setHelloWorld(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public HelloWorld getHelloWorld() {
        return this.helloWorld;
    }
}

D:\worksp\spring\src\main\java\com\yiibai\tutorial\spring\HelloProgram.java

package com.yiibai.tutorial.spring;

import com.yiibai.tutorial.spring.helloworld.HelloWorld;
import com.yiibai.tutorial.spring.helloworld.HelloWorldService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloProgram {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorldService service = (HelloWorldService) context.getBean("helloWorldService");
        HelloWorld hw = service.getHelloWorld();
        hw.sayHello();
    }
}

【"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做】
https://www.w3cschool.cn/wkspring/f8pc1hae.html

由陈创建，Carrie 最后一次修改 2016-08-12

IoC 容器

Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans，我们将在下一章中进行讨论。

通过阅读配置元数据提供的指令，容器知道对哪些对象进行实例化，配置和组装。配置元数据可以通过 XML，Java 注释或 Java 代码来表示。下图是 Spring 如何工作的高级视图。 Spring IoC 容器利用 Java 的 POJO 类和配置元数据来生成完全配置和可执行的系统或应用程序。

IOC 容器具有依赖注入功能的容器，它可以创建对象，IOC 容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制，而"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做。在Spring中BeanFactory是IOC容器的实际代表者。

Spring 提供了以下两种不同类型的容器。

序号	容器 & 描述
1	Spring BeanFactory 容器它是最简单的容器，给 DI 提供了基本的支持，它用 org.springframework.beans.factory.BeanFactory 接口来定义。BeanFactory 或者相关的接口，如 BeanFactoryAware，InitializingBean，DisposableBean，在 Spring 中仍然存在具有大量的与 Spring 整合的第三方框架的反向兼容性的目的。
2	Spring ApplicationContext 容器该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。该容器是由 org.springframework.context.ApplicationContext 接口定义。

序号

容器 & 描述

Spring BeanFactory 容器

它是最简单的容器，给 DI 提供了基本的支持，它用 org.springframework.beans.factory.BeanFactory 接口来定义。BeanFactory 或者相关的接口，如 BeanFactoryAware，InitializingBean，DisposableBean，在 Spring 中仍然存在具有大量的与 Spring 整合的第三方框架的反向兼容性的目的。

Spring ApplicationContext 容器

该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。该容器是由 org.springframework.context.ApplicationContext 接口定义。

ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常建议超过 BeanFactory。BeanFactory 仍然可以用于轻量级的应用程序，如移动设备或基于 applet 的应用程序，其中它的数据量和速度是显著。

Spring BeanFactory 容器

由陈创建，Carrie 最后一次修改 2016-08-12

Sping 的 BeanFactory 容器

这是一个最简单的容器，它主要的功能是为依赖注入（DI）提供支持，这个容器接口在 org.springframework.beans.factory.BeanFactor 中被定义。BeanFactory 和相关的接口，比如BeanFactoryAware、DisposableBean、InitializingBean，仍旧保留在 Spring 中，主要目的是向后兼容已经存在的和那些 Spring 整合在一起的第三方框架。

在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。

在资源宝贵的移动设备或者基于 applet 的应用当中， BeanFactory 会被优先选择。否则，一般使用的是 ApplicationContext，除非你有更好的理由选择 BeanFactory。

例子：

假设我们已经安装 Eclipse IDE，按照下面的步骤，我们可以创建一个 Spring 应用程序。

步骤	描述
1	创建一个名为 SpringExample 的工程并在 src 文件夹下新建一个名为 com.tutorialspoint 文件夹。
2	点击右键，选择 Add External JARs 选项，导入 Spring 的库文件，正如我们在 Spring Hello World Example 章节中提到的导入方式。
3	在 com.tutorialspoint 文件夹下创建 HelloWorld.java 和 MainApp.java两个类文件。
4	在 src 文件夹下创建 Bean 的配置文件 Beans.xml
5	最后的步骤是创建所有 Java 文件和 Bean 的配置文件的内容，按照如下所示步骤运行应用程序。

下面是文件 HelloWorld.java 的内容：

package com.tutorialspoint;

public class HelloWorld {

   private String message;

   public void setMessage(String message){

    this.message  = message;

   }

   public void getMessage(){

    System.out.println("Your Message : " + message);

   }

}

下面是文件 MainApp.java 的内容：

package com.tutorialspoint;

import org.springframework.beans.factory.InitializingBean;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.ClassPathResource;

public class MainApp {

   public static void main(String[] args) {

      XmlBeanFactory factory = new XmlBeanFactory

                             (new ClassPathResource("Beans.xml"));

      HelloWorld obj = (HelloWorld) factory.getBean("helloWorld");

      obj.getMessage();

   }

}

在主程序当中，我们需要注意以下两点：

第一步利用框架提供的 XmlBeanFactory() API 去生成工厂 bean 以及利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件。XmlBeanFactory() API 负责创建并初始化所有的对象，即在配置文件中提到的 bean。
第二步利用第一步生成的 bean 工厂对象的 getBean() 方法得到所需要的 bean。这个方法通过配置文件中的 bean ID 来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。

下面是配置文件 Beans.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-3.0.xsd">

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">

       <property name="message" value="Hello World!"/>

   </bean>

</beans>

如果你已经完成上面的内容，接下来，让我们运行这个应用程序。如果程序没有错误，你将从控制台看到以下信息：

Your Message : Hello

.

└── spring

    ├── pom.xml

    ├── spring.iml

    ├── src

    │   └── main

    │       ├── java

    │       │   └── com

    │       │       └── tutorialspoint

    │       │           ├── HelloWorld.java

    │       │           └── MainApp.java

    │       └── resources

    │           └── beans.xml

    └── target

　　D:\worksp\spring\src\main\resources\beans.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="helloWorld" class="com.tutorialspoint.HelloWorld">
        <property name="message" value="writeInBean"/>
    </bean>
</beans>

D:\worksp\spring\src\main\java\com\tutorialspoint\HelloWorld.java

package com.tutorialspoint;

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your message:" + message);
    }
}

D:\worksp\spring\src\main\java\com\tutorialspoint\MainApp.java

package com.tutorialspoint;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWord");
        obj.getMessage();
    }
}

十一月 28, 2018 5:32:08 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@20ad9418: startup date [Wed Nov 28 17:32:08 CST 2018]; root of context hierarchy
十一月 28, 2018 5:32:08 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'helloWord' is defined
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanDefinition(DefaultListableBeanFactory.java:694)
at org.springframework.beans.factory.support.AbstractBeanFactory.getMergedLocalBeanDefinition(AbstractBeanFactory.java:1168)
at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:281)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194)
at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:956)
at com.tutorialspoint.MainApp.main(MainApp.java:10)

package com.tutorialspoint;

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

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

十一月 28, 2018 5:32:25 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@20ad9418: startup date [Wed Nov 28 17:32:25 CST 2018]; root of context hierarchy
十一月 28, 2018 5:32:26 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
Your message:writeInBean

IoC COntainer Create Javabeans 可以通过读取beans.xml 文件来创建一个应用程序上下文对象依赖反转的更多相关文章

Spring配置文件的加载，及装载多个beans.xml文件
applicationContext.xml 是spring的全局配置文件,用来控制srping的特性 1 手动加载自定义的beans.xml文件 @Test public void testAut ...
自定义beans.xml文件实现Spring框架
经过一天的补习,学习文件加载,java反射,JDom等知识,到了晚上终于能够搭出一个基于配置文件的简单spring框架实现! 首先我们先看看这个问题: 下面是两副图左边是项目结构图,右边是UML图: ...
boost::property_tree读取解析.xml文件
boost::property_tree读取解析.xml文件 1)read_xml 支持中文路径 boost::property_tree::wptree wpt; std::locale:: ...
XML解析之sax解析案例（一）读取contact.xml文件，完整输出文档内容
一.新建Demo2类: import java.io.File; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXPar ...
C#自定义应用程序上下文对象+IOC自己实现依赖注入
以前的好多代码都丢失了,加上最近时间空一些,于是想起整理一下以前的个人半拉子项目,试试让它们重生.自从养成了架构师视觉搭建框架之后,越来越看不上以前搭的框架了.先撸个上下文对象加上实现依赖注入.由 ...
spring框架中beans.xml文件报错XmlBeanDefinitionStoreException
第一次构建spring,实现简单的注入方式,就发生了beans.xml文件报错,报错信息如下图 org.springframework.beans.factory.xml.XmlBeanDefinit ...
死磕Spring之IoC篇 - BeanDefinition 的加载阶段（XML 文件）
该系列文章是本人在学习 Spring 的过程中总结下来的,里面涉及到相关源码,可能对读者不太友好,请结合我的源码注释 Spring 源码分析 GitHub 地址进行阅读 Spring 版本:5.1. ...
C# 读取大型Xml文件
这篇博客将介绍在C#中如何读取数据量很大的Xml文件.请看下面的Xml文件, <?xml version="1.0" encoding="utf-8"?& ...
C# 读取保存xml文件
直接读取xml文件中的内容 XmlDocument xmlDoc = new XmlDocument(); xmlDoc.LoadXml(result); XmlNode root = xmlDoc. ...

随机推荐

LaTeX公式
在学习机器学习中会接触到大量的数学公式,所以在写博客是会非常的麻烦.用公式编辑器一个一个写会非常的麻烦,这时候我们可以使用LaTeX来插入公式. 写这篇博文的目的在于,大家如果要编辑一些简单的公式,就 ...
dos 关机
1.直接调用关机命令 shutdown -s -t 600 (你说的10分钟换算成秒就是600喽,不过这个关机命令不大好,因为始终有个关机倒计时框框显示的) 2.利用at命令调用,在指定时间关机 at ...
java文件读写工具类
依赖jar:commons-io.jar 1.写文件 // by FileUtilsList<String> lines = FileUtils.readLines(file, " ...
启用lazyload插件，减少图片加载
使用lazyload的js插件,减少图片加载,提高页面加载速度和节省流量.虽然这个头像是第三方服务器来的,不消费博客的流量,但是能节省部分访客的加载时间,也是不错的哦. 用lazyload插件,只是后 ...
C语言----项目构建Make,Automake,CMake
http://blog.csdn.net/dc_726/article/details/48978849
Java精选笔记_IO流【File(文件)类、遍历目录下的文件、删除文件及目录】
File(文件)类 File类用于封装一个路径,该路径可以是从系统盘符开始的绝对路径,也可以是相对于当前目录而言的相对路径 File类内部封装的路径可以指向一个文件,也可以指向一个目录,在使用File ...
THINKPHP include 标签动态加载文件
有时候需要在框架中动态的加载一些文件,文件名不确定,有控制器获取得到,想在模板中使用变量的形式进行加载,本以为这样写可以结果不行 <include file="User/{$my_t ...
ios 获取设备相关的信息
.获取设备的信息 UIDevice *device = [[UIDevice alloc] int]; NSString *name = device.name; //获取设备所有者的名称 NSStr ...
MySQL性能优化（一）-- 存储引擎和三范式
一.MySQL存储引擎存储引擎说白了就是如何存储数据.如何为存储的数据建立索引和如何更新.查询数据等技术的实现方法.因为在关系数据库中数据的存储是以表的形式存储的,所以存储引擎也可以称为表类型(即存 ...
Python SQLAlchemy 模块
SQLAlchemy 简介: SQLAlchemy 是用于实现 ORM(Object Relational Mapping,对象关系映射)的一个模块,即把数据库的表结构映射到对象上在 Python 中 ...

IoC COntainer Create Javabeans 可以通过读取beans.xml 文件来创建一个应用程序上下文对象 依赖反转

IoC 容器

Spring BeanFactory 容器

Sping 的 BeanFactory 容器

例子：

IoC COntainer Create Javabeans 可以通过读取beans.xml 文件来创建一个应用程序上下文对象 依赖反转的更多相关文章

随机推荐

热门专题

IoC COntainer Create Javabeans 可以通过读取beans.xml 文件来创建一个应用程序上下文对象依赖反转

IoC COntainer Create Javabeans 可以通过读取beans.xml 文件来创建一个应用程序上下文对象依赖反转的更多相关文章