Spring入门及IOC的介绍

一、Spring概念：
Spring 是一个轻量级的Java开源框架，是为了解决企业应用开发的复杂性而创建的。
Spring 是容器框架，创建bean（相当于一个对象），维护bean之间的关系。实现了程序的解耦合和面向切面(AOP)的容器框架
Spring也是一种集成性框架，可以和其他框架进行整合，从而实现多个框架的协同开发。常见的有(SSH、SSM)。
这里简单打个比方，介绍Spring框架的重要地位

struts2是web框架相对于销售经理，hibernate是orm框架相当于仓库经理，它们两个都是非常优秀的框架，但是相互之间谁都不服谁，而Spring就相当于CEO,可以很好的管理它们，这样好了大家都能一起愉快的协同合作了。

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

&&接下来让我们看看示例

1.导入依赖

<?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>org.example</groupId>
  <artifactId>spring01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>

    <!--junit-->
    <junit.version>4.13</junit.version>
    <!--servlet-->
    <servlet.version>4.0.1</servlet.version>
    <!--spring-->
    <spring.version>5.0.1.RELEASE</spring.version>
  </properties>

  <dependencies>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>

    <!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>

    <!--spring-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

  </dependencies>

  <build>
    <finalName>spring01</finalName>
    <plugins>
      <!--第一步就是配置maven-compiler-plugin插件-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
          <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
      </plugin>


    </plugins>
  </build>
</project>

修改web.xml版本为3.0

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">
</web-app>

建一个Hello实体类

package com.zking.spring01.entity;

import java.io.Serializable;

public class Hello implements Serializable {
    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {

        this.name = name;
    }

    public Hello() {
        System.out.println("new Hello()");
    }

    public Hello(String name) {
        System.out.println("使用有参的构造方法初始化");
        this.name = name;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
    public void  init(){
        System.out.println("正在初始化init方法");
    }
}

Spring的配置文件

在resources文件夹下新建一个配置文件spring.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">
    <!--通过id来直接管理Hello的实例对象-->
    <bean id="hello" name="a b c" class="com.zking.spring01.entity.Hello" scope="prototype" init-method="init">
        <property name="name">
            <value>李四</value>
        </property>
    </bean>
</beans>

再来个Demo案例

package com.zking.spring01.util;
 
import com.zking.spring01.entity.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Demo {
    public static void main(String[] args) {
        //1.什么是spring
        //Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架
        //核心概念:
        //控制反转 IOC：控制权由应用代码中转到了外部容器
        //依赖注入 DI：由容器动态的将某种依赖关系注入到组件之中
        //示例：biz层依赖dao接口
        //作用：用于管理各种各样的JavaBean对象
 
        //理解：将以前由程序员实例化对象/赋值的工作交给了spring处理
 
        //示例1：传统方式与spring方式的区别
        /*Hello hello=new Hello();
        hello.setName("张三");
        System.out.println(hello);*/
 
        //初始化spring上下文（context）,ioc:用于管理各种各样的JavaBean对象的容器框架
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        Hello hello = ac.getBean("hello", Hello.class);
        System.out.println(hello.getName());
    }
 
}

1.读取加载单个文件

ApplicationContext ac=new ClassPathXmlApplicationContext("配置文件名");
2.读取加载多个文件

ApplicationContext ac=new ClassPathXmlApplicationContext(new String[]{"配置文件名1","配置文件名2"});
3.通配方式

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-*.xml");

依赖注入的作用: 将以前由程序员实例化对象/赋值的工作交给了spring处理

5.2，IoC配置文件详解
1.id：在容器中查找Bean的id(唯一、且不能以/开头)
2.class：bean的完整类名 
3.name：在容器中查找Bean的名字(唯一、允许以/开头、允许多个值，多个值之间用逗号或空格隔开)
4.scope:(singleton|prototype)默认是singleton
        4.1.singleton(单例模式)：在每个Spring IoC容器中一个bean定义对应一个对象实例
        4.2.prototype(原型模式/多例模式)：一个bean定义对应多个对象实例
5.abstract：将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象6.bean,非抽象类也可以定义成抽象bean
7.parent：指定一个父bean(必须要有继承关系才行)
8.init-method：指定bean的初始化方法
9.constructor-arg：使用有参数构造方法创建javaBean
 

日期格式

Demo的代码

 

 复杂属性

数组 ,List ,Map , Properties

 总结:IOC需要理解的就是,IOC将以前由程序员实例化对象/赋值的工作交给了spring处理