spring(1)——简介、引入IOC导论、IOC本质、快速上手Spring、IOC创建对象方式、Spring配置

1 spring 简介

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
官网 : http://spring.io/
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
GitHub : https://github.com/spring-projects

优点
1、Spring是一个开源免费的框架 , 容器 .
2、Spring是一个轻量级的框架 , 非侵入式的 .
3、控制反转 IoC , 面向切面 Aop
4、对事物的支持 , 对框架的支持
…
一句话概括：
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

2 IOC推导

1UserDao接口
2UserDaoImpl实现类
3UserService业务接口
4UserSericeImpl业务实现类

解决方案

以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 。这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型

3 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

4 快速上手Spring

依赖注入

  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

代码编写
Hello.java

package com.zs.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Hello {
    
    
    private String name;

}

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就是java对象 , 由Spring创建和管理  
 Bean 管理是指两个操作：
 1. Spring创建对象
 2. Spring注入属性-->
    <bean id="hello" class="com.zs.pojo.Hello">
       <property name="name" value="zs"/>
    </bean>

</beans>

Test.java

package com.zs.pojo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    
    
    @org.junit.Test
    public void test() {
    
    
        // 获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 我们的对象都在spring中管理了 我们要使用直接去里面取就可以了！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收

对IOC导论程序的修改
UserServiceImpl.java

package com.zs.service;

import com.zs.dao.UserDao;
import lombok.Data;

@Data
public class UserServiceImpl implements UserService{
    
    
    private UserDao userDao;
    @Override
    public void getUser() {
    
    
        userDao.getUser();
    }
}

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 管理是指两个操作：
 1. Spring创建对象
 2. Spring注入属性-->
    <bean id="userMysqlImpl" class="com.zs.dao.UserMySqlDaoImpl"/>
    <bean id="userOrcalImpl" class="com.zs.dao.UserOrcalDaoImpl"/>

    <bean id="userSerivceImpl" class="com.zs.service.UserServiceImpl">
        <property name="userDao" ref="userMysqlImpl"/>
    </bean>
</beans>

5 IOC创建对象方式

通过无参构造方法来创建

    <bean id="userMysqlImpl" class="com.zs.dao.UserMySqlDaoImpl"/>
    <bean id="userOrcalImpl" class="com.zs.dao.UserOrcalDaoImpl"/>

通过有参构造方法来创建

    <bean id="user" class="com.zs.pojo.User">
       <constructor-arg name="name" value="zs"/>
    </bean>

在配置文件加载的时候。其中管理的对象都已经初始化了

6 Spring配置

1别名

<bean id="userSerivceImpl" class="com.zs.service.UserServiceImpl">
        <property name="userDao" ref="userMysqlImpl"/>
    </bean>
    <alias name="userSerivceImpl" alias="alias-userSerivceImpl"/>

UserServiceImpl userSerivceImpl = (UserServiceImpl) context.getBean(“alias-userSerivceImpl”);

2Bean的配置
id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
如果配置id,又配置了name,那么name是别名
name可以设置多个别名,可以用逗号,分号,空格隔开
class是bean的全限定名=包名+类名

 <bean id="userSerivceImpl" name="userService1,userService2" class="com.zs.service.UserServiceImpl">
        <property name="userDao" ref="userMysqlImpl"/>
    </bean>

UserServiceImpl userSerivceImpl = (UserServiceImpl) context.getBean(“userService1”);

3import
团队的合作通过import来实现 ，将到多个配置文件导入为一个

<import resource="{path}/beans.xml"/>