Spring
一.MVC思想
一种编程思想
将项目分层3大类
M:Model 数据模型(User.java)
V:View视图(页面jsp html …)
C:Controller 控制器(控制业务逻辑 例如web层 dao层)
二.框架介绍
框架整体介绍
Bean管理 | Spring框架 |
---|---|
持久层操作 | MyBatis Hibernate SpringDataJpa |
servlet开发 | SpringMVC框架 |
微服务 | 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
- 由Spring框架提供
- 默认通过
类型
进行匹配(IOC容器…单例)
2. @Resource
- 由jdk提供
- 默认通过
名字
匹配 - 如果不指定名字,名字为空,则通过类型匹配
推荐使用@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个文件