推荐学习：

Spring的出现是为了解决企业应用程序开发的复杂性 它是一个分层的、JavaSE/EE一站式、轻量级开源框架。

Spring框架是一个分层架构，它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming）、Instrumentation和测试部分。

spring的两个核心是 ioc 和 aop；
IoC（Inversion of Control 控制反转）：将对象创建的权利交给spring工厂来控制。
AOP（Aspect Oriented Programming 面向切面编程），基于动态代理的功能增强方式。

本章主要学习下ioc的内容；

第一步 ： 创建工程导入jar 包。

 <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="#34;
         xmlns:xsi="#34;
         xsi:schemaLocation=" #34;>
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>
123456789101112131415161718192021222324252627282930313233343536373839  

spring 有4个核心容器的jar 包 分别是Beans、Core、Context、SpEL这里我们只要引入spring-context依赖就足够了。

添加log4j.properties文件放置到src/reources下。

 
log4j.rootLogger=INFO,A1
log4j.logger.org.apache=INFO
log4j.appender.A1.Target=System.err
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c]-[%p] %m%n
1234567  

ps：这里的日志等级可以改为debug的级别，这里为了简便设置为info的级别，有需要可以自行更改。

接下来就是写下的伪登录业务；

快速写下dao层和service层业务

 package com.spring.quickTest;

public interface userDao {

    public void queryUser();
    
}

12345678  

 package com.spring.quickTest;

public class UserDaoImpl  implements userDao  {


    @Override
    public void queryUser() {
        System.out.println("用户登录了");
    }
}

1234567891011  

 package com.spring.quickTest;

public interface UserService {

  void login();


}

123456789  

 package com.spring.quickTest;

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

public class UserServiceImpl implements UserService {

    private  userDao userDao;

    public void setUserDao(com.spring.quickTest.userDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void login() {
        System.out.println("准备登录中");
//        1.传统方法
//         userDao userDao = new UserDaoImpl();
//         userDao.queryUser();
//        2.自定义工厂
//        userDao user = (userDao) new UserdaoFactory().getBean();
//           user.queryUser();
//        3spring 工厂
//        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//        userDao userDao = (com.spring.quickTest.userDao) context.getBean("userDao");
        
        userDao.queryUser();

    }
}

12345678910111213141516171819202122232425262728293031  

传统方法下的代码过于耦合；
例如：UserDao userDao = new UserDaoImpl();
如果要更换实现类，或者实现类换一个名字，此时代码会报错，必须要修改原来的业务代码。
我们也可以通过反射的方法自定义一个bean工厂来实现代码的解耦；

 package com.spring.quickTest;

public class UserdaoFactory {

    public Object getBean() {


        try {
            return Class.forName("com.spring.quickTest.UserDaoImpl").newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

       return  null ;
    }
}
1234567891011121314151617181920  

我们就可以通过自定义的工厂进行实例化，然后调用dao层的方法，避免了耦合。

接下来也可以通过spring的工厂来实现解耦；
写好spring核心文件的配置文件applicationContext.xml

 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="#34;
       xmlns:xsi="#34;
       xsi:schemaLocation="
         #34;>
      
     <bean name="userDao" class="com.spring.quickTest.UserDaoImpl"/>
    
      <bean name="UserService" class="com.spring.quickTest.UserServiceImpl">
           <property name="userDao" ref="userDao"></property>
      </bean>
</beans>
123456789101112  

我们将dao层交给spring 工厂后发现还是不够方便，就将service层也交给spring工厂来控制 ，将bean标签下的 property进行依赖注入这样我们只要声明下成员变量后并进行set方法赋值就可以直接引用了，不需要在创建spring工厂了。

ps：
标签说明： bean: spring工厂创建的一个对象(反射机制)
id/name:对象的名字,可以用来引用或者获取对象, 一般为类名或接口名称的首字母小写
class:要创建的对象类型的类字符串,类名全路径
注入对象
property 根据类中的setter方法进行属性注入
name:setter方法的后缀小写,比如setXxx 对应的name为xxx
ref:引用哪一个bean(对象),值为bean的id/name

 import com.spring.quickTest.UserServiceImpl;
import com.spring.quickTest.UserService;
import com.spring.quickTest.UserdaoFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class userTest {
    @Test
    public void test(){
//       UserService service = new UserServiceImpl();
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService service = (UserService) context.getBean("UserService");
        service.login();
    }
}

1234567891011121314151617  

创建完测试类后运行成功。。。

感谢阅读，三连是最大的支持！