Rod Johnson(Spring之父)
ExpertOne-to-OneJ2EEDesignand Development(2002)
阐述了J2EE使用EJB开发设计的优点及解决方案
ExpertOne-to-OneJ2EEDevelopment without EJB(2004)
阐述了J2EE开发不使用EJB的解决方式(Spring雏形)

2017年9月份发布了Spring的最新版本 Spring5.0通用版(GA)

Spring优势

①方便解耦，简化开发

通过Spring提供的loC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

②AOP编程的支持

通过Sprina的aop功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现

③声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量

④方便程序的测试

可以用非容器依赖的编程方式进行几平所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情

⑤方便集成各种优秀框架

Spring对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的支持。

⑥降低JavaEE API的使用难度

Spring对JavaEEapi(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些API的使用难度大为降低

⑦Java 源码是经典学习范例

Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

Spring的体系结构

Spring快速入门

Spring程序开发步骤

①导入Spring开发的基本包坐标

②编写Dao接口和实现类

③创建Spring核心配置文件

④在Spring配置文件中配置UserDaoImpl

⑤使用Spring的API获得Bean

这种方式完成了解耦，后续只需要给配置文件即可

idea中快速入门

①：在pom.xml中配置spring的坐标

        org.springframework    spring-context    5.0.5.RELEASE

②：在src下创建com.Dao.UserDao

创建一个接口

public interface UserDao {    public void play();}

创建UserDao的实现类

import com.Dao.UserDao;public class UserDaoImpl implements UserDao {    public void play(){        System.out.println("play and play...");    }}

③：创建spring核心配置文件(文件的名字任意)

一般起名为applicationContext.xml

④在Spring配置文件中配置UserDaoImpl(id任意)

⑤：使用springAPI获得Bean

创建一个Demo包下的UserDemo

import com.Dao.UserDao;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserDemo {    public static void main(String[] args) {        ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");        UserDao userDao = (UserDao) app.getBean("userDao");        userDao.play();    }}

运行之后：

Spring配置文件

Bean标签基本配置

用于配置对象交由Spring来创建

默认情况下他调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

id：Bean实例在Spring容器中的唯一标识

class：Bean的限定名称

Bean标签范围配置

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Porlet环境那么globalSession相当于session

下pom.xml中配置junit的坐标

         junit      junit      4.11

在test模块下创建text类

package com;import com.Dao.UserDao;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class text {    @Test    public void text1(){        ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");        UserDao userDao1 = (UserDao) app.getBean("userDao");        UserDao userDao2 = (UserDao) app.getBean("userDao");        System.out.println(userDao1);        System.out.println(userDao2);       }}

使用singleton打印出来的地址一致说明容器中只有一份

使用prototype打印出来的地址不一致说明容器中有多份

无参构造创建时机

1)当scope的取值为singleton时

Bean的实例化个数:1个

Bean的实例化时机:当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期:

对象创建:当应用加载，创建容器时，对象就被创建了
对象运行:只要容器在，对象一直活着
对象销毁:当应用卸载，销毁容器时，对象就被销毁了

2)当scope取值为prototype时

Bean的实例化个数:多个

Bean的实例化时机:当调用getBean()方法时实例化Bean

Bean的生命周期

对象创建:当使用对象时，创建新的对象实例
对象运行:只要对象在使用中，就一直活着
对象销毁:当对象长时间不用时，被Java的垃圾回收器回收了

Bean生命周期配置

init-method：指定类中的初始化方法名称

destory-method：指定类中的销毁方法名称

在UserDaoImp类下

创建的初始化方法init和销毁方法destory(名字为任意的)

public class UserDaoImpl implements UserDao {    public void play(){        System.out.println("play and play...");    }    public UserDaoImpl(){        System.out.println("UserDaoImpl被创建");    }    public void init(){        System.out.println("初始化方法");    }    public void destory(){        System.out.println("销毁方法");    }}

在applicationContext.xml文件中指定初始化和销毁方法

在UserDemo方法运行结果：

Bean实例化三种方式

无参构造方法实例化

工厂静态方法实例化

工厂实例方法实例化

①：工厂静态方法实例化

创建一个factory包下

package com.factory;import com.Dao.UserDao;import com.Dao.impl.UserDaoImpl;public class StaticFactory {    public static UserDao getUserDao(){        return new UserDaoImpl();    }}

xml中配置：

在userDemo下运行，或者在test运行也可

② 工厂实例方法实例化演示

创建一个DynamicFactory类

import com.Dao.UserDao;import com.Dao.impl.UserDaoImpl;public class DynamicFactory {    public UserDao getUserDao(){        return new UserDaoImpl();    }}

在applicationContext.xml中

其余代码不变，在text下运行得

Bean的依赖注入分析

创建一个Service服务层的接口和实现类

接口中写入

public interface UserService {    public void save();}

service服务层的实现类去实现save方法

public class UserServiceImpl implements UserService {    @Override    public void save() {        ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");        UserDao userDao = (UserDao) app.getBean("userDao");         userDao.save();    }}

dao持久层下的接口和实现类

public interface UserDao {    public void save();}

实现类下

public class UserDaoImpl implements UserDao {    public void save(){        System.out.println("run save...");    }}

resource下的applicationContext.xml下

在demo包下模拟web环境的创建一个UserController

import com.Service.UserService;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserController {    public static void main(String[] args) {        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = (UserService) app.getBean("userService");        userService.save();    }}

运行之后

依赖注入概念

上面的缺点也很明显，是同时获取service和dao层的到时我们只想要service层，所以此时，需要依赖注入，把dao注入到service服务层

依赖注入(DependencyInjection):它是Spring框架核心ioc的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。 IOC解耦只是降低他们的依赖关系，但不会消除。例如:业务层仍会调用持久层的方法。

那这种业务层(Service)和持久层(Dao)的依赖关系，在使用Spring之后，就让Spring来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

将UserDao注入到UserService内部的方式

构造方法和set方法

法1：set方法

在UserServiceImpl下创建userDao

import com.Dao.UserDao;import com.Service.UserService;public class UserServiceImpl implements UserService {    private UserDao userDao;    public void setUserDao(UserDao userDao) {        this.userDao = userDao;    }    @Override    public void save() {        userDao.save();    }}

在applicationContext.xml文件中配置

然后之前创建的UserController就可以启动了

如果直接new UserServiceImpl对象会报空指针异常的错，

因为useDao是不是通过spring容器来获取的，自然就是null值了

set注入方法改进

P命名空间注入本质也是set方法注入，但比起上述的set方法更加方便，首先需要引入p命名空间：

   xmlns:p="Http://www.springframework.org/schema/p"

修改注入方式

是一个对象就用-ref，普通属性就不用

userController运行之后

有参构造注入方法

在applicationContext.xml文件中

userServiceImpl下

运行结果：

Bean的依赖注入的数据类型

上面的操作，都是注入引用Bean，除了对象的引用可以注入，普通数据类型，集合都可以在容器中进行注入。

注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型

普通数据注入，如在UserDao层注入两个普通数据类型(采用set方式注入)

public class UserDaoImpl implements UserDao {    private String name;    private int  age;    public void setName(String name) {        this.name = name;    }    public void setAge(int age) {        this.age = age;    }    public void save(){        System.out.println("姓名："+name+"年龄:"+age);        System.out.println("run save...");    }}

在applicationContext.xml文件中，在配置dao中设置参数

在Usercontroller下

public class UserController {    public static void main(String[] args) {        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = (UserService) app.getBean("userService");        userService.save();    }}

运行结果

集合的数据类型注入

在UserDaoImpl下

采用set注入方式，设置集合，提供对应得set方法

package com.Dao.impl;import com.Dao.UserDao;import com.pojo.User;import java.util.List;import java.util.Map;import java.util.Properties;public class UserDaoImpl implements UserDao {private List strList;private Map userMap;private Properties properties;    public void setStrList(List strList) {        this.strList = strList;    }    public void setUserMap(Map userMap) {        this.userMap = userMap;    }    public void setProperties(Properties properties) {        this.properties = properties;    }    public void play(){        System.out.println("play and play...");    }    public void save(){        System.out.println("List集合-》"+strList);        System.out.println("Map集合-》"+userMap);        System.out.println("properties集合-》"+properties);        System.out.println("run save...");    }}

在applicationContext.xml下配置注入值

                                               慧慧                孔超                宝                                                                                               宝1                宝2

在UserController测试下

import com.Service.UserService;        import org.springframework.context.ApplicationContext;        import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserController {    public static void main(String[] args) {        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = (UserService) app.getBean("userService");        userService.save();    }}

运行结果：

引入其他配置文件(分模块开发)

实际开发中，Spring的配置内容非常的多，这就导致Spring配置很繁琐且体积很大，所以可以将部分配置拆解到其他配置文件中，而且主配置文件通过import标签进行加载

语法格式：

Spring的重点配置

标签

id属性：在容器中Bean实例的唯一标识，不允许重复
class属性：要实例化的Bean的全限定名
scope属性：bean的作用范围，常用是Singleton(默认)和prototype

标签：属性注入

name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值

标签

标签：导入其他的Spring的分文件

Spring相关的API

ApplicationContext的继承体系

applicationContext：接口类型，代表应用上下文，可以通过其实例获得Spring容器中的Bean对象

紫色的为接口，浅绿色的为抽象类，绿色的为实现类

ApplicationContext的实现类

①ClassPathXmlApplicationContext

它是从类的跟路径下加载配置文件，只需要创建resource下的xml，参数写入xxx.xml即可(推荐使用)

②FileSystemXmlApplicationContext

他是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

③AnnotationConfigApplicationContext

当使用注解配置容器对象时，需要食用此类来创建spring容器骂他用来读取注解

getBean()方法使用

//根据id找public object getBean(String name) throws BeansException {    assertBeanFactoryActive();    return getBeanFactory().getBean(name);}//根据字节码对象找public  T getBean(Class requiredType) throws BeansException {    assertBeanFactoryActive();    return getBeanFactory().getBean(requiredType);}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器这种获得Bean实例，返回Object，需要强转。当参数的数据类型是Class类型是，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个是是，则clss方法会报错

根据id

根据字节码对象

某一类型的bean对象存在多对时，只能使用id，因为id是唯一的，某一类型的bean对象存在一对是时，可以用id，也可以使用字节码对象，使用字节码对象更方便些。

Spring配置数据源(连接池)

数据源（连接池）是提高程序性能出现的
事先实例化数据源，初始化部分连接资源
使用连接资源时从数据源中获取
使用完毕后将连接资源归还给数据源

常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

数据源的开发步骤

导入数据源的坐标和数据库驱动坐标
创建数据源对象
设置数据源的基本连接数据
使用数据源获取连接资源和归还连接资源

①：导入数据源坐标

            Mysql      mysql-connector-java      5.1.32    //c3p0数据源          c3p0      c3p0      0.9.1.2    //druid数据源          com.alibaba      druid      1.1.10                  junit      junit      4.11      test

在test测试中创建类

package com.test;import com.mchange.v2.c3p0.ComboPooledDataSource;import org.junit.Test;import java.sql.Connection;public class DateSourceTest {    @Test    public void test1() throws Exception{        ComboPooledDataSource dataSource=new ComboPooledDataSource();        dataSource.setDriverClass("com.mysql.jdbc.Driver");        //访问数据库中kc_db01库        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/kc_db01");        //数据库的账号密码        dataSource.setUser("root");        dataSource.setPassword("123456");        Connection connection=dataSource.getConnection();        System.out.println(connection);        connection.close();    }}

运行结果

打印出地址说明连接成功

测试连接druid

    @Test    public void test2() throws Exception{        DruidDataSource dataSource=new DruidDataSource();        dataSource.setDriverClassName("com.mysql.jdbc.Driver");        //访问数据库中kc_db01库        dataSource.setUrl("jdbc:mysql://localhost:3306/kc_db01");        //数据库的账号密码        dataSource.setUsername("root");        dataSource.setPassword("123456");        Connection connection=dataSource.getConnection();        System.out.println(connection);        connection.close();    }

加载配置文件方式创建

在resource资源下创建一个MyJdbc.properties文件测试c3p0数据源)

内容是：

jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/kc_db01jdbc.username=rootjdbc.passWord=123456

在测试类中：

  @Test    //测试手动创建c3p0数据库源(加载properties配置文件)    public void test3() throws Exception{        //读取配置文件,获取的参数是你设置的配置文件的名字，        ResourceBundle rb=ResourceBundle.getBundle("MyJdbc");        String driver=rb.getString("jdbc.driver");        String url=rb.getString("jdbc.url");        String username=rb.getString("jdbc.username");        String password=rb.getString("jdbc.password");        //创建数据源对象，设置连接参数        ComboPooledDataSource dataSource=new ComboPooledDataSource();        dataSource.setDriverClass(driver);        dataSource.setJdbcUrl(url);        dataSource.setUser(username);        dataSource.setPassword(password);        Connection connection=dataSource.getConnection();        System.out.println(connection);        connection.close();    }

运行结果：

配置文件的好处有给程序解耦，打完包之后不会变化，程序打完包都是对应的字节码文件，而配置文件还是原模原样。

将DateSource的创建权交给Spring容器去完成

先在pom.xml导入spring的基本坐标

          org.springframework      spring-context      5.0.5.RELEASE

在resource资源下创建ApplicationContext.xml

在DataSourceTest类下

   @Test    public void test4() throws Exception{        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");       // DataSource dataSource= (DataSource) app.getBean("dataSource");      DataSource dataSource= app.getBean(DataSource.class);        Connection connection=dataSource.getConnection();        System.out.println(connection);        connection.close();    }

运行结果

抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息

首先，需要引入context命名空间和约束路径：

命名空间：

xmlns:context="http://www.springframework.org/schema/context"

约束路径：

http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd

applicationContext.xml文件

MyJdbc.properties文件下

jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/kc_db01jdbc.username=rootjdbc.password=123456

类中代码不变，运行结果为

Spring注解开发

Spring是轻代码而中配置，配置比较繁琐，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

Spring原始注解

Spring原始注解主要是替代的配置

注意：使用注解进行开发是，需要在applicationContext.xml中配置组件扫描，作用是值定哪个宝及其子包下的Bean需要进行扫描以便识别使用注解的类、字段个方法

使用注解改进

在com包下创建Dao包，service包，web包

在Dao包下的UserDao接口

public interface UserDao {    public void save();}

在Dao包下的Impl包下的UserDaoImpl类

注解替换位置

//@Component("userDao")//这个注解和上面xml一样

package com.Dao.impl;import com.Dao.UserDao;import org.springframework.stereotype.Component;//@Component("userDao")//这个注解和上面xml一样public class UserDaoImpl implements UserDao {    @Override    public void save() {        System.out.println("running...");    }}

service包下的UserService接口

public interface UserService {    public void save();}

service包下的Impl包下的UserServiceImpl类

注解替换位置

//  @Component("userService")//这是一个组件,这个注解等于以上的xml配置

    //    @Autowired  // 这个表示自动注入    @Qualifier("userDao")//里面写要注入的bean的id

package com.service.Impl;import com.Dao.UserDao;import com.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Component;//  @Component("userService")//这是一个组件public class UserServiceImpl implements UserService {    //    @Autowired  // 这个表示自动注入    @Qualifier("userDao")//里面写要注入的bean的id    private UserDao userDao;  //使用注解可以不写set方法       @Override    public void save() {        userDao.save();    }}

在web包下的UserController类下

package com.web;import com.service.UserService;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserController {    public static void main(String[] args) {        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");        UserService userService = app.getBean(UserService.class);        userService.save();    }}

运行结果

在UserServiceImpl中其他改进写法

@Component("userService")//这是一个组件public class UserServiceImpl implements UserService {    //    @Autowired  // 按照数据类型从Spring容器中进行匹配的    private UserDao userDao;        @Override    public void save() {        userDao.save();    }}

如果根据id进行匹配就要

    @Autowired  // 按照数据类型从Spring容器中进行匹配的    @Qualifier("userDao")//是按照id从容器中进行匹配的，但是主要此处的 @Qualifier结合@Autowired一起使用

 @Resource(name ="userDao")//等价于 @Autowired +@Qualifier

package com.service.Impl;import com.Dao.UserDao;import com.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Component;import javax.annotation.Resource;//  @Component("userService")//这是一个组件public class UserServiceImpl implements UserService {    ////    @Autowired  // 按照数据类型从Spring容器中进行匹配的//    @Qualifier("userDao")//是按照id从容器中进行匹配的，但是主要此处的 @Qualifier结合@Autowired一起使用   @Resource(name ="userDao")//等价于 @Autowired +@Qualifier    private UserDao userDao;    @Override    public void save() {        userDao.save();    }}

使用注解的方式set方法可以省略不写，使用想xml配置就必须写，注解是通过反射

注解方式注入普通值

@Value可以注入值，一般使用el表达式获取配置文件中的值

   @Value("${jdbc.driver}")    private String user;

运行结果

也可以注入普通值，但是显示十分的多余,下面两种方式一样。

@Value("hello")private String test;private String test="hello";

初始方法注解

在serviceImpl中

    @PostConstructpublic void init(){    System.out.println("初始方法");}@PreDestroypublic void destory(){    System.out.println("销毁方法");}

Spring新注解

使用上面的注解还不能全部不代替xml配置文件，还需要使用注解替代的配置如下：

非自定义的Bean的配置：

加载properties文件的配置：

组件扫描的配置：

引入其他文件：

spring新注解

使用新注解替换xml文件

在config包下，创建名为DataSourceConfiguration类下

package com.config;import com.mchange.v2.c3p0.ComboPooledDataSource;import org.springframework.beans.PropertyAccessException;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.PropertySource;import javax.sql.DataSource;import java.beans.PropertyVetoException;// 加载外部properties文件@PropertySource("classpath:MyJdbc.properties")public class DataSourceConfiguration {    @Value("${jdbc.driver}")    private String driver;    @Value("${jdbc.url}")    private String url;    @Value("${jdbc.password}")    private String password;    @Value("${jdbc.username}")    private String username;    @Bean("dataSource")//Spring会将当前方法的返回值以指定名称存储到Spring容器中    public DataSource getDateSource() throws PropertyAccessException, PropertyVetoException {        ComboPooledDataSource dataSource=new ComboPooledDataSource();        dataSource.setDriverClass(driver);        dataSource.setJdbcUrl(url);        dataSource.setPassword(password);        dataSource.setUser(username);        return dataSource;    }}

在config包下创建SprinGConfiguration类下

package com.config;import com.mchange.v2.c3p0.ComboPooledDataSource;import org.springframework.beans.PropertyAccessException;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.*;import javax.sql.DataSource;import java.beans.PropertyVetoException;//标志该类是Spring的核心配置类@Configuration// base是基本包他会扫描其子类下的所有包@ComponentScan("com")//在总配置中加载分配置,加载核心配置类，若有多个,则写xx.class,xxx.class....@Import(DataSourceConfiguration.class)public class SpringConfiguration {}

web包下的UserController测试下

package com.web;import com.config.SpringConfiguration;import com.service.UserService;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserController {    public static void main(String[] args) {        //ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfiguration.class);        UserService userService = app.getBean(UserService.class);        userService.save();    }}

运行结果

Spring集成Junit

原始Junit测试Spring的问题

在测试类中，每个测试方法都有一下两行代码：

//获得应用上下文对象ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");//获取要被测试的对象IAccountService as=ac.getBean("accountService"，IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常，所以又不能轻易删除。

解决思路

让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉他
将需要进行测试Bean直接在测试类中进行注入

Spring集成Junit步骤

①导入spring集成Junit的坐标(首先导入好junit)

②使用@Runwith注解替换原来的运行期

③使用@ContextConfiguration指定配置文件或配置类

④使用@Autowired注入需要测试的对象

⑤创建测试方法进行测试

在pom.xml中导入

            org.springframework      spring-context      5.0.5.RELEASE              junit      junit      4.12              org.springframework      spring-test      5.0.5.RELEASE

在test包下创建SpringJunitTest类

package com.test;import com.service.UserService;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;//指定Spring提供的内核去测试@RunWith(SpringJUnit4ClassRunner.class)//将要测试的文件告诉它@ContextConfiguration("classpath:ApplicationContext.xml")public class SpringJunitTest {    @Autowired    private UserService userService;    @Test    public void test1(){        userService.save();    }}

测试结果

Spring与Web环境集成

在创建dao包，创建service包，创建web包，在resource资源

在创建一个UserDao和UserDaoImpl实现类

接口下

package com.dao;public interface UserDao {    public void save();}

实现类

package com.dao.Impl;import com.dao.UserDao;public class UserDaoImpl implements UserDao {    public void save() {        System.out.println("save running...");    }}

service包下，创建UserService和UserServiceImpl

接口

package com.service;public interface UserService {    public void save();}

实现类下

package com.service.Impl;import com.dao.UserDao;import com.service.UserService;public class UserServiceImpl implements UserService {    public UserDao userDao;    public void setUserDao(UserDao userDao) {        this.userDao = userDao;    }    public void save() {        userDao.save();    }}

pom.xml下

               junit      junit      4.11              org.springframework      spring-test      5.0.5.RELEASE              javax.servlet.jsp      javax.servlet.jsp-api      2.2.1      provided              javax.servlet.jsp      javax.servlet.jsp-api      2.2.1      provided              org.springframework      spring-context      5.3.0      compile

resource资源路径下

applicationContext.xml下

web包下，UserServlet类下，使用注解完成配置

package com.web;import com.service.UserService;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.httpservlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;//使用注解代替web.xml中的配置@WebServlet("/user")public class UserServlet extends HttpServlet  {    @Override    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");        UserService userService = app.getBean(UserService.class);        userService.save();        System.out.println("jin");    }}

项目结构总览

给Maven配置Tomcat服务器

首先这得是war包，如果这是普通包得添加webapp，并将pom.xml中加入如下，表示这是一个web文件

war

加完之后点击编辑配置

其下的war二选一即可

完成之后点击确认即可完成配置。

使用maven手动创建web工程

第一步，点击项目结构，选中要添加的maven工程，右键添加web。

第二步，点击web工程，修改web工程路径

点击完成即可完成web工程的手动配置。

ApplicationContext应用上下文获取方法

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Sprina的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

新建一个Listenter包下的ContextLoderListener

package com.Listener;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.servlet.ServletContext;import javax.servlet.ServletContextEvent;import javax.servlet.ServletContextListener;public class ContextLoaderListener implements ServletContextListener {    public void contextInitialized(ServletContextEvent servletContextEvent) {        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");        //将Spring的应用上下文对象存储到ServletContext域中        ServletContext servletContext = servletContextEvent.getServletContext();        servletContext.setAttribute("app", app);        System.out.println("Spring容器创建完毕");    }    public void contextDestroyed(ServletContextEvent servletContextEvent) {    }}

web包下

package com.web;import com.service.*;import org.springframework.context.ApplicationContext;import javax.servlet.ServletContext;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;@WebServlet("/user")public class UserServlet extends HttpServlet {    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {     //   ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");    ServletContext servletContext = req.getServletContext();    ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");    UserService userService=app.getBean(UserService.class);    }}

web.xml下配置监听器

                com.Listener.ContextLoaderListener

自动创建spring容器

优化代码

解耦合1

由于监听器内部我们将代码写固定了，不利于后期的维护操作，所以要解耦合，写在配置文件中进行解耦合。（“”引号内的名字任意）

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

将此个代码写入到web.xml中进

                 ContextConfigLocation        applicationContext.xml

在ContextLoaderListenter类中

package com.Listener;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import javax.servlet.ServletContext;import javax.servlet.ServletContextEvent;import javax.servlet.ServletContextListener;public class ContextLoaderListener implements ServletContextListener {    public void contextInitialized(ServletContextEvent servletContextEvent) {        ServletContext servletContext = servletContextEvent.getServletContext();        //读取web.xml中的全局参数       String contextConfigLocation = servletContext.getInitParameter("ContextConfigLocation");        ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);        //将Spring的应用上下文对象存储到ServletContext域中        servletContext.setAttribute("app", app);        System.out.println("Spring容器创建完毕");    }}

读取配置文件的值，这样就完成了解耦合

解耦合2

在userServlet类中

ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");

这样耦合了app代码，让这个只能叫做app，这样不利于后期维护和辨认。

所以我们这么改，在Listener包下创建一个工具类WebApplicationContextUtils

package com.Listener;import org.springframework.context.ApplicationContext;import javax.servlet.ServletContext;public class WebApplicationContextUtils {    public static ApplicationContext getApplicationContext(ServletContext servletContext){        return (ApplicationContext) servletContext.getAttribute("app");    }}

在userServlet处代码修改为

package com.web;        import com.Listener.WebApplicationContextUtils;        import com.service.*;        import org.springframework.context.ApplicationContext;        import javax.servlet.ServletContext;        import javax.servlet.ServletException;        import javax.servlet.annotation.WebServlet;        import javax.servlet.http.HttpServlet;        import javax.servlet.http.HttpServletRequest;        import javax.servlet.http.HttpServletResponse;        import java.io.IOException;@WebServlet("/user")public class UserServlet extends HttpServlet {    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        //   ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");        ServletContext servletContext = req.getServletContext();        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");     //变动处        ApplicationContext app = WebApplicationContextUtils.getApplicationContext(servletContext);        UserService userService=app.getBean(UserService.class);    }}

spring自带的监听器

上面写出的手动实现的监听器，Spring提供了一个监听器ContextLoderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供一个客户亿工具WebApplicationContextUtils供使用者获得上下文对象

要使用监听器，需要做两件事：

①：在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）

②：使用WebApplicationContextUtils获得应用上下文对象 ApplicationContext

在pim.xml中导入坐标

              org.springframework            spring-web            5.0.5.RELEASE

web.xml中

                 ContextConfigLocation        classpath:applicationContext.xml                    org.springframework.web.context.ContextLoaderListener

userServlet类中，使用WebApplicationUtils获得上下文

@WebServlet("/user")public class UserServlet extends HttpServlet {    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        //   ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");        ServletContext servletContext = req.getServletContext();        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");     //变动处        //ApplicationContext app = WebApplicationContextUtils.getApplicationContext(servletContext);        WebApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);        UserService userService=app.getBean(UserService.class);    }}

这样就成功使用了spring给我们提供的监听器。

springMVC概述

SpringMVC（M:Model模型，V:views视图，C：Controller控制器）是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow中。

Springmvc已经成为目前最主流的MVC框架之一，并且随着Spring3.0的发布，全面超越Struct2，成为最优秀的MVC框架，他通过一套注解，让一个简单的Java类成为处理请求的控制器，而无须实现任何接口，同时他还支持RESTful编程分格的请求

web层的框架完成的相应的操作图示

SpringMVC的核心是前端控制器，SpringMVC使用Servlet充当前端控制器

SpringMVC开发使用步骤

需求：：客户端发起请求，服务器接受请求，执行逻辑并进行视图跳转。

先导入SpringMVC的相关坐标

配置SpringMVC核心控制器DispathcerServlet

创建Controller类和视图界面

使用注解配置Controller类中业务方法的映射地址

配置SpringMVC核心文件spring-mvc.xml

客户端发起请求测试

②、导入坐标

                  org.springframework            spring-webmvc            5.0.5.RELEASE

②、配置控制器

            DispatcherServlet        org.springframework.web.servlet.DispatcherServlet        1        DispatcherServlet    /

③、创建controller视图和视图界面④、使用注解映射地址

创建一个controller包，包下创建一个userController类，类中

package com.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;//配置类，使用注解把这个类放到容器中@Controllerpublic class userController {//用注解给这个方法请求映射某个地址    @RequestMapping("/quick")    public String save(){        System.out.println("controller save running");       //就会跳转到KCandZH.jsp这个页面上去        return "KCandZH.jsp";    }}

在webapp下创建一个KCandZH.jsp页面

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %><%    String path = request.getContextPath();    String basepath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";%>            Insert title herekCandZH forever

⑤、配置核心spring-mvc.xml（web.xml中）

            DispatcherServlet        org.springframework.web.servlet.DispatcherServlet                    contextConfigLocation            classpath:spring-mvc.xml                        1        DispatcherServlet    /

在resource下写一个spring-mvc.xml用于组件扫描

SpringMVC流程图示

SpringMVC的组件解析

SpringMVC执行流程

①用户发送请求至前端控制器DispatcherServlet（负责组件调度）。

②DispatcherServlet收到请求调用HandlerMapping处理器映射器。

③处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet

④ DispatcherServlet调用HandlerAdapter处理器适配器。

⑤ HandlerAdapter经过适配调用具体的处理器(Controller（封装特有行为的后端代码），也叫后端控制器)。

⑥Controller执行完成返回ModelAndView。

⑦HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

⑧DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

⑨ViewReslover解析后返回具体View。

⑩DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。DispatcherServlet响应用户。

执行流程图示

SpringMVC注解解析

@RequestMapping

作用：用于建立请求URL和处理请求方法之间的对应关系

位置：①类上，请求URL的第一级访问目录，此处不写的话，就相当于应用的根目录

②方法上，请求URL的第二级访问目录，与类上的使用@RequestMapping标注的以及目录一起组成访问虚拟路径。

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="KongChao")public class userController {//用注解给这个方法请求映射某个地址    //所以访问这个地址则是http://localhost:8080/KongChao/ZengHui    @RequestMapping("/ZengHui")    public String save(){        System.out.println("controller save running");       //就会跳转到KCandZH.jsp这个页面上去        //加个/表示从web工程下开始        return "/KCandZH.jsp";    }}

属性：

value：用于指定请求的URL，他和path属性作用是一样的，只有一个url可以省略value，有多个用逗号隔开【如：
```
@RequestMapping(value="user")@RequestMapping("user ")
```
method:用于指定请求的方式（不是这种请求无法访问）
params：用于指定限制请求参数的条件，他支持简单的表达式，要求请求参数的key和value必须和配置的一模一样，如：
```
params={"accoubtName"},表示请求参数必须要accountName，直接在？后面写这个参数即可params={"eys!4"}，表示请求参数中的money不能是4
```
```
 @RequestMapping(value = "/ZengHui",method = RequestMethod.GET,params = {"KCaZH"})
```
则访问路径是ZengHui，请求方式是GET，带有参数KCaZH

xxx内容可以任意，只要带有指定的参数即可。

mvc命名空间引入

命名空间:xmlns:context="http://www.springframework.org/schema/context"        xmlns:mvc="http://www.springframework.org/schema/mvc"约束地址:http://www.springframework.org/schema/context        http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc        http://www.springframework.org/schema/mvc/spring-mvc.xsd

组件扫描基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用

进行组件扫描

SpringMVC的xml配置解析

视图解析器

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.propertier配置文件中配置的，该配置文件地址org/springframework/web/servlet/DospatcherServlet.properties,该文件中配置了默认视图解析器，如下：

org.springframework.web.servlet.ViewResolver=org.springframework .web.servlet.view.InternalResourceViewResolver

翻看该解析器源码，可以看到该解析器的默认设置，如下:REDIRECT URL PREFIX = "redirect:" --重定向前缀FORWARD URL PREFIX="forward:" --转发前缀(默认值) prefix=""; --视图名称前缀 suffix =""; --视图名称后缀

在webapp下新建一个jsp包，则每次访问视图，需要加上/jsp/xxx.jsp

前面的是文件夹的名字，后面的是扩展名，每次都需要加上，这十分的麻烦，所以我们可以在spring-mvc.xml(名字自定义的)配置文件中，配置前缀和后缀

配置完成之后，我们只需写jsp的名字即可，它会自动给我们拼接上前后缀

SpringMVC的相关组件

前端控制器:DispatcherServlet(负责调用其他功能组件，需要手动配置)
处理器映射器:HandlerMapping
处理器适配器:HandlerAdapter（被前端控制器调用，去执行处理器）
处理器:Handler（可以理解为Controller，把一些特有行为进行封装的组件）
视图解析器:ViewResolver.（负责把view解析处理）
视图:View（视图的一些信息）

SpringMVC的注解和配置

请求映射注解:@RequestMapping（作用是进行虚拟地址映射，可以放在类上，也可以放在方法上）
视图解析器配置:
REDIRECT URL PREFIX="redirect:" （重定向）
FORWARD URL PREFIX ="forward:"（转法)（默认值，可以不写）
prefix = "";（前缀）
suffix= "";（后缀）

SpringMVC的数据响应

SpringMVC的数据响应方式

①页面跳转

直接返回字符串（如在一个方法中，return了一个"xxx.jsp"，就会转发到那个jsp页面中，这就是直接返回字符串的形式）
通过ModelAndView对象返回

②回写数据

直接返回字符串（相当于在javaweb里的resp.getwrite(),print）
返回对象或集合

页面跳转

1、返回字符串形式

直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。

返回带有前缀的字符串：

转发：forward:/WEB_INF/views/index.jsp(forward可以省略不写)重定向：redirect:/index.jsp

2、返回ModelAndView对象

方式1：直接new对象

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="KongChao")public class userController {    @RequestMapping(value = "/ZengHui2")    public ModelAndView save2(){                ModelAndView modelAndView=new ModelAndView();        //设置模型数据(键值对，键为String，值为Oject)        modelAndView.addObject("username", 1);        //设置视图名字        modelAndView.setViewName("KCandZH");//经过前后缀拼接就位/jsp/KCandZH.jsp        return modelAndView;    }}

在jsp包下的KCandZH.jsp中

            Insert title herekCandZH forever  ${username}

加上一个El表达式，这样浏览器访问localhost:8080/KongChao/ZengHui2，就会显示出kCandZH forever 1

方式2:写在方法里让SpringMVC创建

也可以不new对象的方式，在方法中直接写model对象，SpringMVC会自动帮你创建

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="KongChao")public class userController {    @RequestMapping(value = "/ZengHui3")    public ModelAndView save3( ModelAndView modelAndView){        //设置模型数据(键值对，键为String，值为Oject)        modelAndView.addObject("username", "babala");        //设置视图名字        modelAndView.setViewName("KCandZH");//经过前后缀拼接就位/jsp/KCandZH.jsp        return modelAndView;    }}

方式3：model和view分开做

model是SpringMVC框架封装好的

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/KongChao")public class userController {    @RequestMapping(value = "/ZengHui4")    public String save4(Model model){//是model        //设置模型数据(键值对，键为String，值为Oject)      model.addAttribute("username","曾慧");      return "KCandZH";//是view    }}

方式4：通过HttpServletRequest

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/KongChao")public class userController {    @RequestMapping(value = "/ZengHui5")    public String save5(HttpServletRequest request){//是model        //设置模型数据(键值对，键为String，值为Oject)        request.setAttribute("username","kckckc");                return "KCandZH";    }}

方式3和方式4的区别，model是SpringMVC封装好的，而HttpServletRequest是原生的javaweb，是由tomcat服务器产生的，这个产生的对象中有数据，有http请求的数据（请求行，请求体....）,model对象则是空的。方式4不常用

回写数据

直接返回字符串

Web基础截断，客户端访问服务器端，如果想直接回写字符串作为响应题返回的话，只需要使用response.getWrite().print("KCandZH")即可，所以在Controller中想直接回写字符串，可以直接在方法中写入response。

方法1：通过SpringMVC框架注入的response对象，使用response.getWrite().print("hello")回写数据，此时不需要视图跳转，业务方法返回值为void

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")public class userController {    @RequestMapping("/quick6")    public void save6(HttpServletResponse response) throws IOException {        response.getWriter().print("hello itcase");    }}

②将需要回写的字符串直接返回，但需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转某个视图，而是直接在http响应体重返回。（加上则不会进行前后缀拼接）

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")  @ResponseBody//告诉SpringMVC框架不进行视图跳转，而是直接进行数据响应public class userController {    @RequestMapping("/quick7")    public String  save7(HttpServletResponse response) throws IOException {        return "hello itcase";    }}

将字符串转成JSON格式回传到客户端

user类下

package com.pojo;public class User {    private int age;    private String username;    public User() {    }    public void setAge(int age) {        this.age = age;    }    public void setName(String username) {        this.username = username;    }}

userController类下

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {        @RequestMapping("/quick9")        @ResponseBody        public String save9() throws JsonProcessingException {            User user=new User();            user.setAge(30);            user.setName("lisi");        //使用json的转换工具将对象转换成json格式字符串再返回            ObjectMapper objectMapper=new ObjectMapper();            String json = objectMapper.writeValueAsString(user);            return json;        }}

要使用json转换工具，还得导入依赖

                    com.fasterxml.jackson.core            jackson-core            2.9.0                            com.fasterxml.jackson.core            jackson-databind            2.9.0                            com.fasterxml.jackson.core            jackson-annotations            2.9.0

运行结果

2、直接返回对象或集合

使用SpringMVC自动将对象或集合转化为json格式

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数是，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行这样配置

配置spring-mvc.xml中处理器映射器

在userController类中

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick10")    @ResponseBody    //配置完成处理器映射器后，SpringMVC会将USer转化为json格式    public User save10() throws JsonProcessingException {        User user=new User();        user.setAge(32);        user.setName("lisi2");        return user;    }}

运行结果

注解方式优化转化json

在方法上添加@ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置。

、

在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件。使用自动加载RequestMappingHandlerMapping(处理映射器)和RequestMappingHandlerAdapter(处理适配器)，可用在Spring-xml.xml配置文件中使用替代注解处理器和适配器的配置。
同时使用默认底层就会集成jackson进行对象或集合的json格式字符串的转换

因为使用了mvc命名空间，所以得导入mvc

在spring-mvc.xml配置文件中

这样就完成了注解配置

SpringMVC获得请求数据

获得请求参数

客户端请求参数的格式是：name=value&name=value.....

服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接受如下类型的参数：

基本数据类型
pojo类型参数
数据类型参数
集合类型参数

基本数据类型

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick11")    @ResponseBody    public void save11(String username,int age)  {        System.out.println(username);        System.out.println(age);    }}

这个方法不进行页面跳转和回写数据@ResponseBody和void）

然后在网页访问书写参数

就可以看到控制台打印出张三 18，这就是基本数据类型

获得POJO类型参数

Controller中的业务方法的pojo参数的属性名与请求参数的name一直，参数值会自动映射匹配

如：

上图中的username和age属于User之中的，SpringMVC就会自动将这些值加进User去

pojo包下的User类

package com.pojo;public class User {    private int age;    private String username;    public User() {    }    public User(int age, String username) {        this.age = age;        this.username = username;    }    public void setAge(int age) {        this.age = age;    }    public int getAge() {        return age;    }    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    @Override    public String toString() {        return "User{" +                "age=" + age +                ", username='" + username + '\'' +                '}';    }}

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick12")    @ResponseBody    public void save12(User user)  {        System.out.println(user);    }}

控制台可以看到

获得数组类型参数

Controller的业务方法数组名称与请求参数的name一致，参数值救赎自动映射配置。

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick13")    @ResponseBody    public void save13(String[] strs)  {        //数组直接打印是地址，为了更清楚看到，用Arrays，asList（作为集合打印）        System.out.println(Arrays.asList(strs));    }}

网址搜素输入

控制台显示

获得集合类型参数

获得集合参数时，要将集合参数包装到pojo对象才可以

所以我们在pojo包下创建一个vo对象

package com.pojo;import java.util.List;public class VO {    private List userList;    public VO(List userList) {        this.userList = userList;    }    public List getUserList() {        return userList;    }    public void setUserList(List userList) {        this.userList = userList;    }    @Override    public String toString() {        return "VO{" +                "userList=" + userList +                '}';    }}

userController类下

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick14")    @ResponseBody    public void save14(VO vo){        System.out.println(vo);    }}

fORM.jsp页面下

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %><%    String path = request.getContextPath();    String basepath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";%>            Insert title here<%--表明是第一个User对象username age--%>

运行之后在页面输入数据，控制台输出

获得集合类型参数

静态资源访问的开启

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以是直接接收结合数据而无需使用POJO进行包装。

创建一个js下的

还有ajax.jsp

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8" %><%    String path = request.getContextPath();    String basepath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";%>            Insert title here

userController类下

//配置类，使用注解把这个类放到容器中@Controller@RequestMapping(value="/user")    public class userController {    @RequestMapping("/quick15")    @ResponseBody    public void save15(@ResponseBody List userList) throws Exception {        System.out.println(userList);    }}

运行服务器后，发现控制台没有打印数据

一般是页面出现了问题，打开开发者工具中查看

发现是这个Jquery文件找不到

这是静态资源访问权限的问题，解决方式是在spring-mvc中加入

    ⑤编写Mapper接口（dao接口） public interface AccountMapper {   @Insert(" insert into account values(#{id},#{name},#{money})")    public void save(Account account);@Select(" select * from account")    public List findAll();}
  ⑥编写service接口
 public interface AccountService {    public void save(Account account);    public List findAll();}
  ⑦编写Service接口实现
 @Service("accountService")public class AccountServiceImpl implements AccountService {    @Autowired    private AccountMapper accountMapper;    @Override    public void save(Account account) {        accountMapper.save(account);    }    @Override    public List findAll() {        return accountMapper.findAll();    }}
  ⑧编写Controller
 @Controller@RequestMapping("/account")public class AccountController {    @Autowired    private AccountService accountService;    //保存    @RequestMapping(value = "/save",produces = "text/html;charset=UTF-8")@ResponseBody    public String save(Account account){        accountService.save(account);        return  "提交成功";    }    //查询    @RequestMapping("/findAll")    public ModelAndView findAll(){        List accountList =  accountService.findAll();        ModelAndView modelAndView = new ModelAndView();        modelAndView.addObject("accountList",accountList);        modelAndView.setViewName("accountList");        return modelAndView;    }}
  ⑨编写jsp添加页面
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>    Title    添加账户信息表单
            账户名称:
        账户金额:
        
    
  ⑩编写列表jsp展示页面
 <%@ page contentType="text/html;charset=UTF-8" language="java" %><%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>    Title    展示账户数据列表
                                    账户id             账户名称             账户金额         
                        ${account.id}                 ${account.name}                 ${account.money}             
            
 ①①编写响应的配置文件
 applicationContext.xml
                                                                                                                                                                                                                             
 jdbc.properties
 jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/SSMjdbc.username=rootjdbc.password=123456
 
 spring-mvc.xml
                                                 
 
 sqlMapConfig.xml
                                                                                                                                                             
 
 sqlMapConfig-spring.xml
                             
 web.xml
         contextConfigLocation    classpath:applicationContext.xml        org.springframework.web.context.ContextLoaderListener          DispatcherServlet    org.springframework.web.servlet.DispatcherServlet          contextConfigLocation      classpath:spring-mvc.xml        1        DispatcherServlet    /          CharacterEncodingFilter    org.springframework.web.filter.CharacterEncodingFilter          encoding      UTF-8            CharacterEncodingFilter    /*  
 
 ①②测试添加账户和账户列表
 
 ①③数据库中测试
 
 来源地址：https://blog.csdn.net/weixin_60719453/article/details/126674166

账户id	账户名称	账户金额
${account.id}	${account.name}	${account.money}



您可能感兴趣的文档:

SQL 代码规范
MySQL 教程
Redis 教程



点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料




--结束END--
 本文标题: 13万字学会Spring+SpringMVC+Mybatis框架
 本文链接: https://www.lsjlt.com/news/419602.html(转载时请注明来源链接)
有问题或投稿请发送至:
邮箱/279061341@qq.com    QQ/279061341






本篇文章演示代码以及资料文档资料下载
下载Word文档到电脑，方便收藏和打印～


下载Word文档



去做题




猜你喜欢







13万字学会Spring+SpringMVC+Mybatis框架
 目录 Spring介绍 Spring是什么 Spring发展历程 Spring优势 Spring的体系结构   Spring快速入门 Spring程序开发步骤 idea中快速入门  Spring配置文件 Bean标签基本配置 Bean标签范...

 




99+
2023-09-27

mybatis
java
mysql
spring
springmvc








SSM框架整合（Spring+SpringMVC+MyBatis）
 【SSM的系统架构】【整合概述】　　MyBatis和Spring整合，通过Spring管理mapper接口。　　使用mapper的扫描器自动扫描mapper接口在Spring中进行注册。　　通过Spring管理Service接口。　　使用配...

 




99+
2023-06-03









Spring+SpringMVC+MyBatis+Maven框架整合
 
                本文记录了Spring+SpringMVC+MyBatis+Maven框架整合的记录，主要记录以下几点 一、Maven需要引入的jar包 二、Spring与SpringMVC的配置分离&...

 




99+
2024-04-02









Spring+SpringMVC+MyBatis整合实战(SSM框架)
 
                            目录SpringMVCSpringMyBatis项目结构maven配置文件pom.xmlwebapp配置文件web.xmlspring配置文件applicationContext.x...

 




99+
2024-04-02









如何使用Maven搭建SpringMVC+Spring+MyBatis框架
 这篇文章主要介绍如何使用Maven搭建SpringMVC+Spring+MyBatis框架，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！SSM（Spring+SpringMVC+Mybatis），目前较为主流的企业级...

 




99+
2023-05-30

springmvc
spring
mybatis








SSM框架整合之Spring+SpringMVC+MyBatis实践步骤
 
                            目录1、基本概念1.1、Spring1.2、SpringMVC1.3、MyBatis2、开发环境搭建以及创建Maven Web项目3、SSM整合3.1、Maven引入需要的JAR包3...

 




99+
2024-04-02









SSM框架整合之Spring+SpringMVC+MyBatis的示例分析
 这篇文章主要介绍了SSM框架整合之Spring+SpringMVC+MyBatis的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。1、基本概念1.1、SpringSp...

 




99+
2023-06-15









SSM框架的学习与应用(Spring + Spring MVC + MyBatis)-Java EE企业级应用开发学习记录（第五天）MyBatis的注解开发
 SSM框架的学习与应用(Spring + Spring MVC + MyBatis)-Java EE企业级应用开发学习记录（第五天）MyBatis的注解开发  昨天我们深入学习了MyBatis多表之间的关联映射，了解掌握了一对一关联映射，...

 




99+
2023-08-30

学习
spring
mvc
Mybatis






软考高级职称资格查询





广告


软考职称历年真题下载






2023下半年-信息系统项目管理师-真题考点汇总（完整版）

  164.2 KB  
查看






2023年下半年信息系统项目管理师第一、二批次各科目真题考点整理(考友回忆版)

  143.67 KB  
查看






2023上半年软考高级《信息系统项目管理师》真题答案（抢先版）

  500.26 KB  
查看






2022年下半年软考高级职称考试考情分析

  823.36 KB  
查看






2022年下半年软考高级职称考试真题

  569.84 KB  
查看







软考职称资料下载






2023下半年-系统集成项目管理工程师-真题考点汇总（完整版）

  143.91 KB  
查看






2023年下半年系统集成项目管理工程师第一、二、三批次真题考点整理(考友回忆版)

  183.71 KB  
查看






2023年上半年软考中级《系统集成项目管理工程师》-基础知识-考试真题及答案

  644.84 KB  
查看






2023年上半年软考中级《系统集成项目管理工程师》-应用技术-考试真题及答案

  314.7 KB  
查看






2023年下半年第一二批次系统集成项目管理工程师《案例分析》真题考点

  115.57 KB  
查看







热门wiki










mysql删除数据恢复

mysql删表能回滚吗

mysql找回删除的表

mysql不小心删除了表

mysql不小心把表删了怎么恢复数据

mysql数据表删除后能恢复么

mysql误删表数据恢复

mysql误删表恢复

mysql删除表怎么恢复

mysql删除表











近期文章










mysql拒绝访问怎么办

mysql怎么比较日期大小

mysql怎么加锁

mysql误删数据怎么恢复

怎么判断mysql安装成功

mysql怎么修改表名

mysql删除的表怎么恢复

mysql复合主键怎么写

怎么查看mysql数据库版本

怎么检测mysql安装成功











推荐阅读











mysql怎么比较日期大小

2024-05-16







mysql怎么加锁

2024-05-16







mysql删除的表怎么恢复

2024-05-16







sql中exists具体用法

2024-05-15







patindex在sql中的用法

2024-05-15







sql中逻辑运算符的用法

2024-05-15







regexp在sql中的用法

2024-05-15







sql中split函数用法

2024-05-15







sql中leftjoin的用法

2024-05-15







sql中concat用法

2024-05-15
















热门问答













1
回答

如何调试操作系统的错误？
操作系统




2023-11-15发布






1
回答

操作系统中的I/O系统是如何实现的？
操作系统




2023-11-15发布






1
回答

如何实现操作系统的内存管理？
操作系统




2023-11-15发布






1
回答

什么是虚拟内存，它对操作系统有什么影响？
操作系统




2023-11-15发布






1
回答

ASP中的MVC架构和WebForms架构有什么区别和使用场景？
ASP.NET




2023-11-15发布






1
回答

ASP中的数据验证和数据校验有什么不同？
ASP.NET




2023-11-15发布






1
回答

ASP中的ADO对象和DAO对象有什么区别和使用方法？
ASP.NET




2023-11-15发布






1
回答

Node.js中的包管理器NPM是什么？如何使用它进行依赖管理？
node.js




2023-11-15发布






1
回答

Vue.js中的动态组件是什么？如何使用它来动态渲染组件？
VUE




2023-11-15发布






1
回答

如何使用Vue.js实现懒加载和预加载？
VUE




2023-11-15发布













热门标签





单元测试调试
离线功能
半结构化数据
非结构化数据
关键字：定时器
子网
流数据
域名在线交易
库或框架
同步原语
域名担保交易安全吗
域名交易安全
域名担保交易流程是什么样的
域名担保交易流程
域名担保交易
异步读文件
并行数据处理
安全实践
面试技巧
读写二进制文件
跨平台兼容
交叉平台
上下文取消
mpmc
预处理器
自定义分隔符
c++生态系统
开源许可证
还原数据库
程序流