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

②：在class="lazy" data-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}

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

mybatisjavamysqlspringspringmvc

阅读原文内容投诉

13万字学会Spring+SpringMVC+Mybatis框架
下载Word文档到电脑，方便收藏和打印～

下载Word文档

`相关文章`

`猜你喜欢`

13万字学会Spring+SpringMVC+Mybatis框架

2023-09-27

`编程热搜`

Oracle Study--Oracle RAC CacheFusion（MindMap）
报表SQL
[mysql]mysql8修改root密码
use mysqlselect * from user where user="root";update user set password=password("mysql@2020") where user="root";ERROR 1064 (42000)
MySQL专题3之MySQL管理
1、启动以及关闭MySQL服务器- 首先，我们需要通过以下命令来检查MySQL服务器是否已经启动：ps -ef | grep mysqld- 如果MySQL已经启动，以上命令将输出mysql进程列表，如果mysql未启动，你可以使用以下
linux怎么查看mysql版本号
navicat导出csv乱码的方法
Mongodb数据库中mongostat工具用法
mysql如何查看帮助
navicat如何设置外键
centos7如何查看mysql的版本

查看更多

`编程资源站`

资料下载
历年试题

信息系统项目管理师选择题每日一练（2024）历年试题

2023年下半年信息系统项目管理师综合知识真题演练历年试题

查看更多