Spring 01框架简介 搭建 及IOC容器

Spring

一.MVC思想

一种编程思想
将项目分层3大类
M:Model 数据模型(User.java)
V:View视图(页面jsp html …)
C:Controller 控制器(控制业务逻辑 例如web层 dao层)

二.框架介绍

框架整体介绍

Bean管理	Spring框架
持久层操作	MyBatis Hibernate SpringDataJpa
servlet开发	SpringMVC框架 Struts2
微服务	Dubbo(阿里) SpringBoot 和SpringCloud
缓存	Redis…

框架概念

    spring 是众多开源 java 项目中的一员，基于分层的 javaEE 应用一站式轻量级开源框架，主要核心是 Ioc(控制反转/依赖注入 DI 依赖注入) 与 Aop(面向切面)两大技术，实现项目在开发过程中的轻松解耦，提高项目的开发效率。
    在项目中引入 spring 立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。 容器提供单例模式支持，开发人员不再需要自己编写实现代码。 容器提供了 AOP 技术，利用它很容易实现如权限拦截、运行期监控等功能。

源码框架

三.spring框架名词

Ioc 控制翻转与依赖注入
DI 依赖注入
AOP 面向切片编程

四.技术栈

SSH:Struts2 + Spring + Hibernate
SSM:Spring + SpringMVC + Mybatis

五.搭建Spring环境

1.创建Maven项目

2.添加项目依赖

3.编写测试代码

4.编写配置文件

5.执行单元测试

具体流程:

1.创建一个普通Maven项目

pom.xml文件删除修改
版本1.8 单元测试4.12

<?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.xxx</groupId>
  <artifactId>spring01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>spring01</name>

  <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>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  
  <build>
  </build>
</project>

2.添加spring核心框架坐标

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.9.RELEASE</version>
    </dependency>

3.新建HelloService.java

删除main和test中的app.java
复制其中的代码并新建一个
HelloService.java

4.编写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">
    <!--
    xmlns 即 xml namespace xml 使用的命名空间
    xmlns:xsi 即 xml schema instance xml 遵守的具体规范
    xsi:schemaLocation 本文档 xml 遵守的规范 官方指定
    -->
    <bean id="helloService" class="com.xxx.service.HelloService"></bean>
</beans>

5.书写单元测试

选中要测试的类名 Alt+Enter → CreateTest

添加测试类具体代码:

package com.xxx.service;

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

import static org.junit.Assert.*;

public class HelloServiceTest {

    @Test
    public void hello() {
        /*
        * 1.加载配置文件
        * 2.获取HelloService的Bean对象
        * 3.使用bean
        * */
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        HelloService helloService = (HelloService) context.getBean("helloService");

        helloService.Hello();
    }
}

第一句话是通过这段代码能加载到spring.xml
可以右键点击跳转到spring.xml

测试结果:

Hello Spring

六.IOC容器

IOC:控制反转(Inversion of Control)

java中将设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制 (主动变被动)

就像第三方一样,我们提需求,第三方提供资源,不符合要求会抛出异常

控制:

IOC容器 控制→ 对象 (主要控制外部资源获取)

反转:

正转: 传统应用程序是我们自己在对象中直接获取依赖对象

反转: 是由容器来帮忙创建及注入依赖对象;

DI:依赖注入(Dependency Injection)

容器动态的将依赖关系注入到组建之中,为了提升复用,灵活可拓展。

依赖:

APP 依赖于→ IOC容器 (App需要Ioc提供对象所需外部资源)

注入:

IOC 注入→ app某对象 (注入对象所需外部资源)

描述

IOC容器中的bean对象都是单例

七.手动简单模拟IOC容器

准备:

1.xml解析(dom4j + xpath)
2.反射
3. 集合(List Map …)

流程:

1.xml解析

创建一个普通maven项目


简单修改下pom.xml代码

<?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.xxx</groupId>
  <artifactId>spring02-ioc</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>spring02-ioc</name>

  <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>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
  </build>
</project>

添加两个依赖 解析xml

    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>1.6.1</artifactId>
    </dependency>
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>1.1.6</artifactId>
    </dependency>

UserService.java

package com.xxx.service;

public class UserService {
    public static void addUser() {
        System.out.println("UserService addUser");
    }
}

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="userService" class="com.xxx.service.UserService"></bean>
</beans>

ApplicationContext.java

package com.xxx;

public interface ApplicationContext {

    public  Object getBean();

}

XxxApplicationContext.java

package com.xxx;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;

import java.net.URL;
import java.util.List;

public class XxxApplicationContext implements ApplicationContext {

    /*
     * 1.读取xml并解析
     * 2.反射生成bean对象
     * 3.返回执行bean
     * */

    private String xmlPath;// xml配置文件路径

    public XxxApplicationContext(String xmlPath){
        this.xmlPath = xmlPath;
        // 解析xml
        parseXml(xmlPath);
    }

    /**
     * 解析xml
     * @param xmlPath
     */
    private void parseXml(String xmlPath) {
        if (null != xmlPath && !"".equals(xmlPath)){
            // dom4j
            // 这里借鉴官方的代码
            SAXReader reader = new SAXReader();
            try {
                // 1.拿到xml
                URL url = this.getClass().getClassLoader().getResource(xmlPath);
                Document document = reader.read(url);

                // 2. 解析xml
                List<Element> list = document.selectNodes("/beans/bean");

                // 3.获取属性值
                for (Element e : list){
                    System.out.println("id: " + e.attributeValue("id") + "class: " + e.attributeValue("class"));
                }
            } catch (DocumentException e) {
                e.printStackTrace();
            }

        }else{
            System.err.println("文件不存在");
        }
    }


    public Object getBean() {
        return null;
    }
}

测试 XxxApplicationContextTest.java

package com.xxx;

import org.junit.Test;


public class XxxApplicationContextTest {

    @Test
    public void getBean() throws Exception{
        new XxxApplicationContext("spring.xml");
    }
}

结果:

id: userServiceclass: com.xxx.service.UserService

2.反射生成bean对象

ApplicationContext.java

package com.xxx;

public interface ApplicationContext {

    public  Object getBean(String id);

}

XxxBean.java

package com.xxx;

public class XxxBean {
    private String id;
    private String clazz;

    public XxxBean() {
    }

    public XxxBean(String id, String clazz) {
        this.id = id;
        this.clazz = clazz;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }


}

XxxApplicationContext.java

package com.xxx;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;

import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class XxxApplicationContext implements ApplicationContext {

    /*
     * 1.读取xml并解析
     * 2.反射生成bean对象
     * 3.返回执行bean
     * */

    private String xmlPath;// xml配置文件路径
    private List<XxxBean> xxxBeansList = new ArrayList<>();//存储解析结果
    private Map<String,Object> beanMap = new HashMap<>();//存储反射结果

    public XxxApplicationContext(String xmlPath) throws Exception {
        this.xmlPath = xmlPath;
        // 解析xml
        parseXml(xmlPath);
        //反射生成bean
        initBean();
    }

    /**
     * 初始化Bean
     */
    private void initBean() throws Exception {
        if(xxxBeansList.size()>0){
            for (XxxBean bean : xxxBeansList){
                String id = bean.getId();
                String clazz = bean.getClazz();
                beanMap.put(id,Class.forName(clazz).newInstance());
            }
        }
    }

    /**
     * 解析xml
     * @param xmlPath
     */
    private void parseXml(String xmlPath) {
        if (null != xmlPath && !"".equals(xmlPath)){
            // dom4j
            // 这里借鉴官方的代码
            SAXReader reader = new SAXReader();
            try {
                // 1.拿到xml
                URL url = this.getClass().getClassLoader().getResource(xmlPath);
                Document document = reader.read(url);

                // 2. 解析xml
                List<Element> list = document.selectNodes("/beans/bean");

                // 3.获取属性值
                for (Element e : list){
                    //System.out.println("id: " + e.attributeValue("id") + "class: " + e.attributeValue("class"));
                    String id = e.attributeValue("id");
                    String clazz = e.attributeValue("clazz");
                    xxxBeansList.add(new XxxBean(id,clazz));
                }
            } catch (DocumentException e) {
                e.printStackTrace();
            }

        }else{
            System.err.println("文件不存在");
        }
    }

    @Override
    public Object getBean(String id) {
        return beanMap.get(id);
    }
}

测试:

package com.xxx;

import com.xxx.service.UserService;
import org.junit.Test;


public class XxxApplicationContextTest {
    @Test
    public void getBean01() throws Exception {
        ApplicationContext context = new XxxApplicationContext("spring.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.addUser();
    }

    @Test
    public void getBean02() throws Exception {
        ApplicationContext context = new XxxApplicationContext("spring.xml");
        UserService userService1 = (UserService) context.getBean("userService");
        UserService userService2 = (UserService) context.getBean("userService");

        System.out.println(userService1);
        System.out.println(userService2);
    }


}

反射的对象也是单例

八.多文件加载

    Spring 框架启动时可以加载多个配置文件到环境中。对于比较复杂的项目，可能对应的配置文件有多个，项目在启动部署时会将多个配置文件同时加载进来。

Dao.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="userDao" class="com.gy.dao.UserDao"></bean>
</beans>

Service.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="userService" class="com.gy.service.UserService"></bean>
</beans>

Controller.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="userController" 
class="com.shsxt.comtroller.UserController"></bean>
</beans>

此时测试，启动容器时将配置文件同时加载，并获取对应 bean 实例

@Test
public void test01() throws Exception {
	ApplicationContext ac=new
	ClassPathXmlApplicationContext("dao.xml","service.xml","controller.xml");
// 获取 dao 层 bean
	UserDao userDao=(UserDao) ac.getBean("userDao");
	userDao.save();
//获取 service 层 bean
	UserService userService= (UserService) ac.getBean("userService");
	userService.hello();
// 获取 controller bean
	UserController userController=(UserController)
	ac.getBean("userController");
	userController.show();
}

结果如下:

dao层保存方法。。。
service层业务方法。。。
controler层控制方法。。。

使用 import 标签，将子配置文件导入到总配置

<?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">
 <import resource="dao.xml"/>
 <import resource="service.xml"/>
 <import resource="controller.xml"/>
</beans>

测试

@Test
public void test01() throws Exception {
	ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");// 此
	时加载总配置 beans.xml 即可
// 获取 dao 层 bean
	UserDao userDao=(UserDao) ac.getBean("userDao");
	userDao.save();
//获取 service 层 bean
	UserService userService= (UserService) ac.getBean("userService");
	userService.hello();
// 获取 controller bean
	UserController userController=(UserController)
	ac.getBean("userController");
	userController.show();
}

结果如下：

dao层保存方法。。。
service层业务方法。。。
controler层控制方法。。。

九.IOC中实例bean的3种方式

1、 构造器的方式实例化 bean 对象 (80% 其余两种可忽略)

<bean id="userServiceImpl" 
class="com.gy.service.impl.UserServiceImpl"></bean>

通过默认构造器创建 空构造方法必须存在 否则创建失败

2、 静态工厂方法方式实例化 bean

特点:
I.要有该工厂类及工厂方法
II.工厂方法为静态的
静态工厂定义

package com.gy.factory;
import com.gy.service.UserService;
public class StaticFactory {
	public static UserService createUserService() {
		return new UserService();
	}
}

Bean 配置

<bean id="userService" class="com.shsxt.factory.StaticFactory" 
 factory-method="createUserService"/>

当我们指定 Spring 使用静态工厂方法来创建 Bean 实例时，Spring 将先解析配置文件，并根据配置文件指定的信息，通过反射调用静态工厂类的静态工厂方法，并将该静态工厂方法的返回值作为 Bean 实例，在这个过程中，Spring 不再负责创建 Bean 实例，Bean 实例是由用户提供的静态工厂方法提供的。

3、 实例化工厂方式创建 bean

相比较静态工厂实现
I．工厂方法为非静态方法
II.需要配置工厂 bean,并在业务 bean 中配置 factory-bean，factory-method 属性
实例化工厂定义

package com.gy.factory;

import com.gy.service.UserService;
public class InstanceFactory {

	public UserService createUserService() {
		return new UserService();
	}
}

Bean 配置

<!--
 实例化工厂
 1.定义实例化工厂 bean
 2.引用工厂 bean 指定工厂创建方法(方法为非静态)
-->
<bean id="instanceFactory" class="com.shsxt.factory.InstanceFactory"></bean>
<bean id="userService" factory-bean="instanceFactory" factorymethod="createUserService"></bean>

spring 三种实例化 bean 的方式比较

• 方式一：通过 bean 的缺省构造函数创建，当各个 bean 的业务逻辑相互比较独立的时
  候或者和外界关联较少的时候可以使用。
• 方式二：利用静态 factory 方法创建，可以统一管理各个 bean 的创建，如各个 bean
  在创建之前需要相同的初始化处理，则可用这个 factory 方法险进行统一的处理等等。
• 方式三：利用实例化 factory 方法创建，即将 factory 方法也作为了业务 bean 来控制，
  1 可用于集成其他框架的 bean 创建管理方法，2 能够使 bean 和 factory 的角色互换。

开发中项目一般使用一种方式实例化 bean，项目开发基本采用第一种方式，交给 spring 托管，使用时直接拿来使用即可。另外两种了解

九.Spring 依赖注入（Dependency Injection 即 DI）

本质上IOC和DI是一个东西

依赖注入 : 只需定义对象即可 无需new对象

1.手动与引入的问题

2.Spring Ioc注入

1.1 set注入

90%都是用的这种方式

示例:

xml 配置(同时 spring 也提供了对于基本数据类型的 set 注入方式)

<?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="userServiceImpl" class="com.gy.service.impl.UserServiceImpl">
 <property name="userDao" ref="userDao"></property>
 </bean>
  <bean id="userDao" class="com.gy.dao.UserDao"></bean>
</beans>

Java类

package com.gy.service.impl;
import com.gy.dao.UserDao;
import com.gy.vo.User;
public class UserServiceImpl {
	private UserDao userDao;

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}


	public UserDao getUserDao() {
		return userDao;
	}
	public void saveUser(User user) {
		System.out.println("userName:"+userName+"price:"+price);
		userDao.add(user);

	}

}

基本数据类型 set 注入

<bean id="userServiceImpl" class="com.gy.service.impl.UserServiceImpl">
 <property name="userDao" ref="userDao"></property>
 <property name="userName" value="sxt">
 </property>
 <property name="price" value="123">
 </property>
</bean>

同时对应 Service 提供对应属性字段 以及 get 、set 方法即可

1.2 构造器注入

1.3 静态工厂注入

1.4 实例化工厂

p标签 和 c标签

分别对应 简化set注入 和 构造器注入

3.循环依赖的问题产生

4.IOC集合类型属性注入

十.注解注入 ★

1. @Autowired

1. 由Spring框架提供
2. 默认通过类型进行匹配(IOC容器…单例)

2. @Resource

1. 由jdk提供
2. 默认通过名字匹配
3. 如果不指定名字,名字为空,则通过类型匹配

推荐使用@Resource减少了与Spring的耦合度

十一.IOC容器自动扫描管理Bean

1. @Repository

标记Dao层

2. @Service

标记Service层

3. @Controller

标记控制层 web/Controller

4. @Component

标记任意层

这些注解使用,需要先在配置文件添加扫描包,然后只需在类名上面添加注解即可。

• 1.加入 spring-aop jar包 spring-aop-4.3.2.RELEASE.jar
• 2.Xml 配置: 加入 context 命名空间和 xsd 地址
• 3.添加<context:annotation-config/>配置

实际上这四个注解功能都是一样的,只是用来区分,方便管理。

十二.spring简单实现登录功能

pom.xml

<?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.gy</groupId>
  <artifactId>spring-login</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>spring-login</name>

  <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>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>jaxen</artifactId>
      <version>1.1.6</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.9.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
  </build>
</project>

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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

        <!--    开启包扫描-->
        <context:component-scan base-package="com.gy"/>
</beans>

User.java

package com.gy.po;


public class User {
    
    private String name;
    private String pwd;

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

ResultInfo.java

package com.gy.model;


public class ResultInfo {

    private Integer code;
    private String msg;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "ResultInfo{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                '}';
    }
}

UserController.java

package com.gy.controller;

import com.gy.model.ResultInfo;
import com.gy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public ResultInfo login(String name, String pwd){
        return userService.login(name, pwd);
    }

}

UserService.java

package com.gy.service;

import com.gy.dao.UserDao;
import com.gy.model.ResultInfo;
import com.gy.po.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public ResultInfo login(String name, String pwd){
        /**
         * 1.参数校验
         * 2.查询用户
         * 3.比较密码是否正确
         */
        ResultInfo info = new ResultInfo();
        if (null==name || "".equals(name)){
            info.setCode(300);
            info.setMsg("用户名为空");
            return info;
        }
        if (null==pwd || "".equals(pwd)){
            info.setCode(300);
            info.setMsg("密码为空");
            return info;
        }

        User user = userDao.queryUserByName(name);
        if (null==user){
            info.setCode(300);
            info.setMsg("用户不存在");
            return info;
        }

        if (pwd.equals(user.getPwd())){
            info.setCode(200);
            info.setMsg("登录成功");
            return info;
        }else{
            info.setCode(300);
            info.setMsg("用户名或密码不正确");
            return info;
        }
    }
}

UserDao.java

package com.gy.dao;

import com.gy.po.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {

    private final String NAME = "zhangsan";
    private final String PWD = "123456";

    public User queryUserByName(String name){
        User user = null;
        if (name.equals(NAME)){
            user = new User();
            user.setName(NAME);
            user.setPwd(PWD);
        }
        return user;
    }
}

UserControllerTest.java

package com.gy.controller;

import com.gy.model.ResultInfo;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.Assert.*;

public class UserControllerTest {

    @Test
    public void login() throws Exception{
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring.xml");
        UserController userController = (UserController) context.getBean("userController");
        //ResultInfo info = userController.login(null,null);
        //ResultInfo info = userController.login("zhangsan",null);
        //ResultInfo info = userController.login("zhangsan","111111");
        ResultInfo info = userController.login("zhangsan","123456");
        System.out.println(info);
    }
}

EX

一般导入别人的idea项目要删除这3个文件