jy-10-SPRINGMYBATIS01——Spring-成恒

最新推荐文章于 2024-11-15 14:09:57 发布

从码农到码到成功

最新推荐文章于 2024-11-15 14:09:57 发布

阅读量378

点赞数

文章标签： spring java xml

本文链接：https://blog.csdn.net/weixin_39519454/article/details/120663227

版权

1、day01－框架

成恒 / chengheng@tedu.cn

框架是一套已经完成的代码，为我们的开发过程提供便利。

课程主题：SSM

Spring + Spring MVC + Mybatis

回顾：MVC

MVC（Model + View + Controller）是一种设计理念，将程序中的各个部分划分出来，然后表现为不同的类，从而实现“每个类都有自己的定位，只用专注自身的业务或者功能，而不关心其它的部分是如何实现、完成的”！

设计模式

单例模式

单例模式的表现是： 在任何时刻，某个类的实例(对象)只会存在1个！

假设有：

public class User {
    }

则：

User u1 = new User();
User u2 = new User();

即开发者可以创建任意多个User类的对象！要实现单例模式，则应该先：

public class User {
private User() {}
}

一旦私有化构造方法，则不可以随意创建该类的对象，然后：

public class User {
private static User user = new User();
private User() {}
}

接下来：

public class User {
private static User user = new User();
private User() {}
public static User getInstance() {
return user;
}
}

工厂模式

工厂模式的作用是： 生产对象，使得需要对象的那一方不用关心对象的生产过程

通常，应该先设计对象标准，即设计接口：

public interface IUserDao {
void insert(User user);
}

然后，设计接口的实现类：

public class UserDaoImpl implements IUserDao {
public void insert(User user) {}
}

再接下来，设计工厂类：

public class UserDaoFactory {
public static IUserDao newInstance() {
return new UserDaoImpl();
}
}

以上完成后，当需要对象时：

IUserDao dao = UserDaoFactory.newInstance();
dao.insert(...);

可以发现，以上代码中并没有体现出实现类的名字！也就可以理解为： 以上程序中，对UserDaoImpl没有太多的依赖性！也称之为“解耦”！ 即使某天UserDaoImpl类不足以满足程序的需求，只需要另写一个例如UserDaoImpl2也实现IUserDao接口，并修改工厂的返回值即可，整个项目中的其它代码都不需要调整！

Spring框架

开发Spring DEMO

实现步骤

1 创建Maven Project，类型为war

2 配置Maven依赖：spring-webmvc 打开pom.xml，切换到dependencies选项卡，点击Add按钮，输入spring-webmvc，选择Group ID为org.springframework对应的项。注意：Group ID有很多款，请检查！

3 添加Spring配置文件来源：配置文件可以从FTP下载目标位置：src\main\resouces

4 创建被Spring管理的类，可以是任何类例如创建User类

5 创建测试运行的类

6 配置Spring的配置文件添加节点，在节点中添加id和class属性 - id：自定义名称，推荐能与类名联想得上 - class：被管理的类的完整名，即“包名+类名”

7 测试运行

a) 加载配置文件

String file = "applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(file);

b) 调用ac的getBean()方法获取对象 User user = (User) ac.getBean("user");

以上getBean()的参数是XML配置的的id

注意事项

如果切换了Workspace，请在Eclipse的Window菜单中选择Preferences，然后在弹出的Preferences对话框左侧选择Maven -> User Settings，再在右侧的User Settings项选择到正确的maven配置文件。如果以上操作是创建项目后再执行的，并且没有自动解决已经存在的问题，则可能需要对项目点鼠标右键，选择Maven -> Update Project，并勾选Force Update……等待

maven解决了jar包依赖后重新测试项目即可。

-------------------------------------------------------------------------------------------------------------------------

关于getBean()的类型

由ApplicationContext定义的getBean()被重载了多次，其中，getBean(String, Class)的返回值是泛型的！

-------------------------------------------------------------------------------------------------------------------------

关于ApplicationContext的close()

ApplicationContext接口并没有声明close()方法，如果需要关闭，则应该将变量声明为AbstractApplicationContext。

-------------------------------------------------------------------------------------------------------------------------

版本与教学版本不同时的注意事项

如果出现问题，在项目的库中，找到Maven库，再找到spring相关的jar包的某个，例如spring-context-???.jar，展开该jar包，在META-INFO下找到spring.schemas文件，在该文件中找到版本号，然后，修改项目中applicationContext.xml文件中的版本号。各版本号都是统一的，所以，只需要找到其中1个（例如spring-context）的版本号，然后全部修改为这个版本就可以了！

-------------------------------------------------------------------------------------------------------------------------

使用Spring获取对象的方式

通过无参数的构造方法

适用范围：只要对应的类是普通的类（非abstract），并且有无参数的构造方法即可！

配置代码示例：

获取对象示例： Date date = ctx.getBean("date", Date.class);

-------------------------------------------------------------------------------------------------------------------------

通过静态的工厂方法

分析：以Calendar类为例，该类是抽象类，不可以直接创建对象，但是，该类中有静态方法public static Calendar getInstance()，所以，通过Calendar.getInstance()可以获取Calendar类型的对象！

适用范围：该类可能没有无参数的构造方法，但是该类中存在某个静态的无参数方法，可以返回该类的对象。注：要创建对象的类，和提供静态方法的类，必须是同一个类！

配置代码示例： <bean id="calendar" class="java.util.Calendar" factory-method="getInstance" /> 即：相对于使用构造方法，需要多配置 factory-method 属性

获取对象示例： Calendar calendar = ctx.getBean("calendar", Calendar.class);

-------------------------------------------------------------------------------------------------------------------

通过实例工厂方法

分析：当工厂方法不是静态方法，或工厂方法所在的类与需要创建对象的类并不是同一个，则需要使用实例工厂方法来获取对象！

适用范围：另外有个类的方法（不需要是静态方法）可以用于生产对象！

需求示例： public class User { } public class UserFactory { public User getUser() { return new User(); } }

1.项目列表

2.User类

3.UserFactory类

4. applicationContext.xml文件配置

5.TestCase测试类

配置代码示例：说明：因为调用非静态方法之前，必须先创建该类的对象，所以，先配置工厂！然后： <bean id="user" factory-bean="userFactory" factory-method="getUser" />

获取对象示例： User user = ctx.getBean("user", User.class);

-------------------------------------------------------------------------------------------------------------------------

通过Spring管理的Bean的作用域

在默认情况下，Spring管理的类的对象都是单例的，并且在加载Spring配置文件时就已经创建出了bean的对象！

在Spring配置文件中，为节点添加scope属性可以配置作用域，该属性的值可以是singleton，也是默认值，表示单例，也可以取值为prototype，非单例的，并且，在加载Spring配置文件时并不会直接创建对象，而是根据需要（获取对象时）才会创建对象！

通过Spring管理的Bean的生命周期

通过Spring管理的Bean可以设计创建时的初始化生命周期方法和销毁时的生命周期方法。

-------------------------------------------------------------------------------------------------------------------------

开发步骤：

1 在自定义的由Spring管理的Bean类中自行设计这2个方法（或其中的某1个），例如在User类中添加public void init()和public void destroy()方法

实现步骤：

2 在Spring的配置文件中，在User类的节点上添加配置init-method属性和destroy-method属性，属性的值就是第1步中添加的方法的名称

3.TestCase测试类中测试

4.查看结果；默认或scope=singleton的Bean，在构造方法执行结束之后就会执行初始化的生命周期方法，在ApplicationContext对象关闭之后会执行销毁的生命周期方法

5. scope=prototype的Bean，在构造方法执行结束之后就会执行初始化的生命周期方法，并不会执行销毁的生命周期方法

6.测试查看结果

在编写XML文件时没有提示

参考 tctm-art-student-fe 笔记中的《达内 XML schema 代理服务》

[回顾] 内存泄漏与内存溢出

当尝试释放某个资源，却由于该资源正在被使用，无法释放，则可能导致该资源长期存在于内存中！这种状况称之为内存泄漏(Leak)！

其实，少量的内存泄漏是没有危害的！特别是单机运行的程序！

但是，泄漏的数据是无法继续被使用的，却占用了内存空间，也就是无谓的占用了内存！会影响整个计算机运行的性能！

并且，当泄漏的数据越来越多时，就会导致可用的内存越来越少，最极端的表现就是内存中有非常大数量的泄漏数据，导致内存几乎没有可用内存，此时再在内存中创建新的数据，内存会没有空间来存储，就会出现“内存溢出”！

[回顾] 异常的体系结构

Throwable
-- Error
-- Exception
-- -- IOException
-- -- -- FileNotFoundException
-- -- RuntimeException
-- -- -- ClassCastException (??) ???
-- -- -- ArithmeticException  x / 0
-- -- -- NullPointerException null.getxxx  null.xxx
-- -- -- IndexOutOfBoundsException  list.get(-1)
-- -- -- -- ArrayIndexOutOfBoundsException  arr[-1]

2、day02－设计模式

单例模式 - 饿汉式（Eager Singleton）

1.创建User 类：

2.在 applicationContext.xml文件中配置bean

3.在测试类中测试饿汉式：

4.查看执行结果：

设计模式 - 单例模式 - 懒汉式（Lazy Singleton）

懒汉式的单例表现为获取对象时才根据需要创建对象。
public class User {
private static User user = null;
private static Object lock = new Object();
private User() {}
public static User getInstance() {
if (user == null) {
synchronized (lock) {
if (user == null) {
user = new User();
}
}
}
return user;
}
}

1.在项目中创建User类：

2.在 applicationContext.xml文件中配置bean

3.在测试类中测试懒汉式：

4.查看执行结果：

Spring管理Bean时使用懒汉式加载（延迟加载）

Spring管理Bean时，默认是单例的，并且是饿汉式加载，在读取Spring配置文件时就已经创建了Bean的对象！

如果需要Bean是懒汉式加载，则在Spring配置文件中，在对应的节点下，需要添加lazy-init属性，该属性的值可以是default、true、false。

例如： <bean id="user" class="cn.tedu.spring.bean.User" lazy-init="true" />

---------------------------------------------------------------------------------------------------------------------------------

MVC的用户注册

大致流程

View：username, password
Controller -> Model（Service -> Dao）

Model中的代码的模拟实现

public class UserService {
private UserDao userDao;
public void reg(User user) {
dao.insert(user);
}
}
public class UserDao {
public void insert(User user) {
// 访问数据库，添加数据
}
}

在Spring管理的Bean中通过属性的Set方法直接注入属性的值

应用场景

例如UserService中需要UserDao来执行业务

---------------------------------------------------------------------------------------------------------------------------------

开发步骤

1 在UserService中声明UserDao类型的属性 public class UserService { private UserDao dao; }

2 为属性提供规范的Set方法：在属性名前加上set，并且将属性名的首字母大写，这个步骤可以通过开发工具自动Set方法 public class UserService { private UserDao dao;

public void setDao(UserDao arg0) {
dao = arg0;
}
}

3 在Spring的配置文件，配置UserService和UserDao的

4 在Spring的配置文件中，为UserService的添加子级节点，以配置属性值的注入，即：需要修改原有的节点，在节点中，name属性的值必须与UserService类中的属性的名称保持一致，同时，也是设计属性值的Set方法中set单词右侧的字符，首字母是小写，ref的值是需要设置给属性的对象在Spring中配置的的id，即UserDao的的id

在Spring管理的Bean中通过构造方法注入属性的值

开发步骤

1 在UserService中声明UserDao类型的属性 public class UserService { private UserDao dao; }

2 添加构造方法，并在构造方法中通过参数为属性赋值 public class UserService { private UserDao dao;

public UserService(UserDao dao) {
this.dao = dao;
}
}

3 在Spring的配置文件，配置UserService和UserDao的

4 在Spring的配置文件中，为UserService的添加子级<constructor-arg>节点，并为该节点配置index和ref属性，index表示当前配置的构造方法的参数的序号，第1个参数的index为0，第2个参数的为1，以此类推，ref表示引用到的其它bean的id，如果构造方法需要多个参数，则在当前节点下需要配置多个<constructor-arg>节点 <constructor-arg index="0" ref="userDao" />

向Spring管理的Bean中直接注入基本值

哪些是基本值

可以使用直接常量表示的值，包含8种基本数据类型和String

---------------------------------------------------------------------------------------------------------------------------------

怎么设置基本值

构造方法注入值：

1.在类中声明私有属性和构造方法

2.构造方法注入值，则在节点下的<constructor-arg>节点中添加value属性并设置值即可。

index="0"代表第一个参数 value=“20” 代表第一个参数的值

index=“1"代表第二个参数 value=“zhangsan” 代表第二个参数的值

3.在Test测试类中测试

4.查看结果是否注入成功：

注意： 当显式的指定数据类型时，必须保证指定的数据类型与Bean中的Set方法/构造方法要求的参数数据类型保持完全一致！例如Date类存在Date(long)构造方法，则配置在中的type属性值必须是long，而不可以是它的包装类型Long！！！

向Spring管理的Bean中直接注入集合类型的值

利用set注入给属性赋值：

如果是通过Set方式注入值，则在节点下的节点中添加value属性，并设置值即可；

1.在User类中定义私有属性，并生成get/set方法：

2.在配置文件中配置bean并采用set注入方式：

3.在Test测试类中测试：

4.查看结果是否注入成功：

以下是集合类型注入配置：

<!-- 配置List集合的数据 -->
<property name="listData">
<list>
<value>list-data-1</value>
<value>list-data-2</value>
<value>list-data-3</value>
<value>list-data-4</value>
<value>list-data-5</value>
</list>
</property>
<!-- 配置Set集合的数据 -->
<property name="unorderedData">
<set>
<value>set-data-1</value>
<value>set-data-2</value>
<value>set-data-3</value>
<value>set-data-4</value>
<value>set-data-5</value>
</set>
</property>
<!-- 配置Map集合的数据 -->
<property name="mapData">
<map>
<entry key="K-1" value="V-1"></entry>
<entry key="K-2" value="V-2"></entry>
<entry key="K-3" value="V-3"></entry>
<entry key="K-4" value="V-4"></entry>
<entry key="K-5" value="V-5"></entry>
</map>
</property>

[仅了解] 如果配置的是List集合类型，最终数据类型为ArrayList；如果配置的是Set集合类型，最终数据类型是LinkedHashSet；如果配置的是Map集合类型，最终数据类型是LinkedHashMap。

向Spring管理的Bean中直接注入Properties类型的值

通常，Properties类型的数据都源自于读取 .properties文件！Spring框架可以直接读取 .properties文件，并封装为Properties类型的数据！

---------------------------------------------------------------------------------------------------------------------------------

开发步骤

1 在src\main\resources文件夹下创建扩展名为.properties的文件，例如db-config.properties，然后自定义文件内部的配置信息

2 在Spring的配置文件中，在根节点添加<util:properties>节点，并配置id和location属性，其中，id的配置可参考一般节点的id配置，location的值是以classpath:作为前缀，加上.properties配置文件的名称，例如：

<util:properties id="dbConfig"
location="classpath:db-config.properties" />

3 当需要注入某个属性值为Properties类型时，以Set方式注入为例：

<property name="Bean中的属性名称" ref="dbConfig" />

[回顾] List与Set

共同点

都是Collection的子级接口

区别

List集合是有序的/序列的，Set集合是无序的/散列的
List集合中的数据是允许重复的，而Set集合中的数据是唯一的

Set集合中判断数据是否相同/唯一的标准

2个数据的equals()对比结果为true，并且2个数据的hashCode()返回值相同。

[回顾] ArrayList与LinkedList

[回顾] HashSet与TreeSet

3、day03－在Spring中注入Bean属性的值

也可以为Bean属性注入数组值：

不可以使用类似于<util:list>这样的方式来设计数组。

事实上，在注入值时，数组与List可以混为一谈！也就是说，即使某个属性是数组类型的，在注入值时，可以通过ref引用到某个<util:list>设计的List集合！当然，数据类型必须是相符的！

除此以外，还可以为属性注入null值：

如果是字符串类型的属性，还可以注入空值（即""）：

Spring表达式

Spring表达式可以应用于Spring的XML配置文件中。

使用Spring表达式可以在注入值时，引用另一个Bean的属性值，或另一个Bean中的集合中的某个元素……

使用条件：某个BeanX已经被注入值，另一个BeanY的某些值来自于BeanX。

Spring表达式的基本格式是： #{被引用bean的id.属性名称 }

如果引用的是数组或List集合中的某个元素，则： #{被引用bean的id.数组名或集合名称[下标] }

如果引用的是Map或Properties，则： #{被引用bean的id.Map名或Properties名.key}，或： #{被引用bean的id.Map名或Properties名['key']}

1.工程目录：

2.sourceBean.java类

3. TargetBean.java类

4. applicationContext.xml文件配置，

已经定义了sourceBean.java类的属性值如下：

5. 在applicationContext.xml文件中采用Spring表达式获取

sourceBean.java类的属性值配置到TargetBean.java类中的属性上，

配置如下：

6.在测试类中测试

是否将sourceBean.java类的属性值配置到TargetBean.java类中的属性上：

7.查看结果：

[理解] Spring的自动装配（AutoWire）

Spring的自动装配表现为可以自动注入的值，而不需要在XML中通过Set方式或构造方法来进行注入！

基本以上练习，在XML中配置UserService的时：

则Spring会在UserSerivce类中根据属性名(byName)在XML中找对应的，在练习中，UserService中有名为userDao的属性，

则Spring会查找<bean id="userDao" ...>并获取这个的对象，然后会调用UserService中userDao属性对应的Set方法，

即调用setUserDao()方法，把刚才获取到的对象作用调用setUserDao()方法的参数，从而完成自动注入！

在XML配置中，节点中的autowire属性的值可以是：

- no：默认值，不会自动装配。

- byName：根据属性名完成自动装配，要求在XML文件中也存在相同名称的的配置，如果没有对应的，将不会自动装配，也不会报告错误。

- byType：根据属性的类型完成自动装配，要求在XML文件存在与属性的类型相同的Bean的配置，这样的做法对于的id并没有要求！

注意： 如果类型能够匹配到2个或者更多的则会导致程序崩溃！！！ - constructor：基于构造方法，模式可参考byType - autodetect：自动检测

小结：使用Autowire可以简化开发，避免XML配置文件过于臃肿，也可以避免可能存在的的调整，例如出于某种原因修改了的id，

但是，也存在之间的依赖关系表现得不明确的问题！

---------------------------------------------------------------------------------------------------------------------------------

Spring的组件扫描

什么是组件扫描

可以配置Spring对指定的包进行扫描，使得在利用Spring开发时，不必在Spring的XML文件中对Bean进行配置！

Spring扫描指定的包时，就会直接对扫描得到的Bean进行管理！对于开发者而言，

最直接的表现就是不必再配置Spring的XML文件中的节点！

为什么要使用组件扫描

省事！相关的配置均会体现在对应的Java类中，表现得会更加直观，易于调整！

---------------------------------------------------------------------------------------------------------------------------------

基本开发步骤

1 创建支持Spring的项目

2 在Spring的配置文件中，在根节点下，添加<context:component-scan />节点，配置base-package属性，该属性的值是希望Spring管理的那些类在哪个包中！代码例如：

<context:component-scan
base-package="cn.tedu.spring" />
注：配置包的时候，不一定是精确的指向某个类所在的包，可以是更加父级的包名，例如cn.tedu.spring也是可以的，
那么，在cn.tedu.spring.bean或cn.tedu.spring.dao等这些包中的类都将被Spring管理！

3 在需要被Spring管理的类的声明上方添加 @Component 的注解。

---------------------------------------------------------------------------------------------------------------------------------

基本项目的大致实现原理

当Spring扫描到cn.tedu.spring.bean.User类后，会自动根据类名决定将生成的的id为user，即类名的首字母小写后，就是的id，完成节点的配置！

---------------------------------------------------------------------------------------------------------------------------------

为Bean自定义ID

@Component("u")
public class User { }

---------------------------------------------------------------------------------------------------------------------------------

常用于类的注解（详见Spring-程祖红的笔记）

SpringMVC原理

SpringMVC流程

1、用户发送请求至前端控制器DispatcherServlet。

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

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

4、 DispatcherServlet调用HandlerAdapter处理器适配器。

5、 HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、 Controller执行完成返回ModelAndView。

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

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

9、 ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

组件说明：

以下组件通常使用框架提供实现：

DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。

HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器。

ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。

组件：

1、前端控制器DispatcherServlet（不需要工程师开发）,由框架提供

作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。

用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

2、处理器映射器HandlerMapping(不需要工程师开发),由框架提供

作用：根据请求的url查找Handler

HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3、处理器适配器HandlerAdapter

作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4、处理器Handler(需要工程师开发)

注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。

由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。

5、视图解析器View resolver(不需要工程师开发),由框架提供

作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。

6、视图View(需要工程师开发jsp...)

View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf...）

核心架构的具体流程步骤如下：

1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

2、DispatcherServlet——>HandlerMapping， HandlerMapping 将会把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；

3、DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；

5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；

6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；

7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

下边两个组件通常情况下需要开发：

Handler：处理器，即后端控制器用controller表示。

View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。

在将SpringMVC之前我们先来看一下什么是MVC模式

MVC：MVC是一种设计模式

MVC的原理图：

分析：

M-Model 模型（完成业务逻辑：有javaBean构成，service+dao+entity）

V-View 视图（做界面的展示 jsp，html……）

C-Controller 控制器（接收请求—>调用模型—>根据结果派发页面）

springMVC是什么：

　　springMVC是一个MVC的开源框架，springMVC=struts2+spring，springMVC就相当于是Struts2加上sring的整合，但是这里有一个疑惑就是，springMVC和spring是什么样的关系呢？这个在百度百科上有一个很好的解释：意思是说，springMVC是spring的一个后续产品，其实就是spring在原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块（类似AOP，IOC这样的模块），网络上经常会说springMVC和spring无缝集成，其实springMVC就是spring的一个子模块，所以根本不需要同spring进行整合。

SpringMVC的原理图：

看到这个图大家可能会有很多的疑惑，现在我们来看一下这个图的步骤：（可以对比MVC的原理图进行理解）

第一步:用户发起请求到前端控制器（DispatcherServlet）

第二步：前端控制器请求处理器映射器（HandlerMappering）去查找处理器（Handle）：通过xml配置或者注解进行查找

第三步：找到以后处理器映射器（HandlerMappering）像前端控制器返回执行链（HandlerExecutionChain）

第四步：前端控制器（DispatcherServlet）调用处理器适配器（HandlerAdapter）去执行处理器（Handler）

第五步：处理器适配器去执行Handler

第六步：Handler执行完给处理器适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回ModelAndView

第八步：前端控制器请求视图解析器（ViewResolver）去进行视图解析

第九步：视图解析器像前端控制器返回View

第十步：前端控制器对视图进行渲染

第十一步：前端控制器向用户响应结果

看到这些步骤我相信大家很感觉非常的乱，这是正常的，但是这里主要是要大家理解springMVC中的几个组件：

前端控制器（DispatcherServlet）：接收请求，响应结果，相当于电脑的CPU。

处理器映射器（HandlerMapping）：根据URL去查找处理器

处理器（Handler）：（需要程序员去写代码处理逻辑的）

处理器适配器（HandlerAdapter）：会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器（适配器模式的应用）

视图解析器（ViewResovler）：进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面

初步实现：

1.项目目录：

2.创建 HelloController类并实现Controller接口：

3.在web.xml中配置servlet

4.在 applicationContext.xml文件中配置三个组件：

5.在web下的WEB-INF 下写一个hello.jsp文件写入hello world

6.完成运行

4、day04－基于注解的Spring MVC

使用@Controller注解

在Spring MVC设计的WEB应用中，可以使用 @Controller 对控制器类（原本实现Controller的类）进行注解！

一旦使用了 @Controller 注解，控制器类可以不必实现Controller接口！

注意： @Controller注解不可以单独使用，必须匹配@RequestMapping一起使用！

使用@RequestMapping注解

@RequestMapping用于对处理器类中的方法进行注解，并且需要指定所处理的请求的路径，例如：

注意： 使用了@Controller和@RequestMapping的组合之后，原本Spring的XML配置文件中不要再配置HandlerMapping！如果仍然存在HandlerMapping的配置，并且没有当前请求与处理器的映射关系的配置，反而会报错！总之，不要配置HandlerMapping！！！

@RequestMapping不仅仅可以对方法进行注解，也可以用于对处理器类进行注解！但是，对处理器类进行注解不可以取代对方法的注解，两者应该同时使用！用于处理请求路径有多个层级的需求，例如请求路径是：

    http://SERVER:PORT/PROJECT/user/register.do

则使用注解：

@Controller
@RequestMapping("/user")
public class RegisterController {
@RequestMapping("/register.do")
public ModelAndView handleRequest(...

当使用@RequestMapping同时注解处理器类和方法时，两处所写的路径对于组合时的路径分隔符是没有要求的！例如以下组合都是正确的：

/user /register.do 【推荐】
/user register.do
/user/ /register.do
user /register.do
user register.do

小结：@RequestMapping用于配置处理器类和请求路径的映射，必须对处理器类中的方法进行注解，如果请求路径有多层级，可以添加对处理器类的注解，则在对方法的注解中可以少写一些路径。

---------------------------------------------------------------------------------------------------------------------------------

使用同一个Controller处理多种不同的请求

当使用了以上注解后，同一个Controller中可以处理多种不同的请求，并且，类中处理请求的方法是可以自定义的！方法的自定义表现为：

- 方法名称没有要求

- 方法的参数没有要求

- 方法不要声明抛出异常

- 方法必须是public的

- **方法的返回值必须是ModelAndView或者String的**

---------------------------------------------------------------------------------------------------------------------------------

基于注解的Spring MVC开发流程

1 创建项目并完成基础配置：创建项目、解决web.xml的问题、添加spring-webmvc依赖、在resources中粘贴applicationContext.xml、为项目添加Tomcat Runtime

2 在web.xml中配置DispatcherServlet（代码没有修改）

3 在applicationContext中配置组件扫描、ViewResolver，在配置ViewResolver请注意路径是否正确

4 设计请求：http://SERVER:PORT/PROJECT/user/login.do

5 创建用于处理请求的控制器类，使用@Controller进行注解，并使用@RequestMapping对路径（/user）进行注解：

@Controller
@RequestMapping("/user")
public class UserController {
}

6 在控制器类中添加处理请求的方法，并使用@RequestMapping映射到请求的资源：

@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/login.do")
public String showLoginForm() {
return null;
}
}

7 完善处理请求的方法，如果对于此次请求只需要转发到JSP页面，则处理方法的返回值类型设计为String即可！返回值就是最终负责显示的View组件的名称！暂时可以理解为JSP页面的文件名（不包含.jsp部分）！

8 设计JSP页面，注意：JSP页面的位置必须与Spring的XML配置文件中的前缀配置保持一致，同时，JSP页面的文件名与以上第7步返回值的字符串保持一致！

9 将部分添加到Server进行管理，重新部署到Tomcat，测试运行！

---------------------------------------------------------------------------------------------------------------------------------

练习

项目名称：DAY04-02-SpringMVC-Sample

请求路径：http://SERVER:PORT/PROJECT/user/register.do

处理器类：cn.tedu.spring.controller.UserController

处理方法：public String showRegisterForm() { }

JSP页面：user register form.jsp

JSP页面内容：至少3个输入框，内容包括：用户名(username)、密码(password)、月薪(salary)

本案例不实现提交后的处理

---------------------------------------------------------------------------------------------------------------------------------

获取请求参数

通过HttpRequestServlet获取请求参数

在处理请求的方法中，添加HttpServletRequest参数，例如：

public String handleRegister(HttpServletRequest request) {
// ...
}

说明：添加HttpServletRequest参数时，不一定需要添加HttpServletResponse参数。

当添加参数后，在方法中，调用参数的getParameter(String)方法即可获取请求参数的值，做法同使用Servlet编程。

---------------------------------------------------------------------------------------------------------------------------------

通过添加处理请求的方法的参数获取请求参数值

在处理请求的方法中，声明与前端页面（html/jsp/...）的表单中相同名称的参数，则这个参数将自动被赋上用户提交的值。

public String handleRegister(String username, String password, int salary) {
// 直接使用以上参数即可，这些参数已经被赋值
}

以上方式要求参数的名称与前端页面的表单中的名称保持一致！如果参数名与表单中使用的名称不同，可以使用 @RequestParam 注解：

public String handlerRegister(
String username, // 名称相同，则直接使用
@RequestParam("password") String pwd // 名称不同，则注解
) {
// ...
}

尽管这种方式简单易用，但是，不太适用于提交的数据个数偏多的应用场景，假设某个业务需要用户提交20个数据，则为方法添加20个参数是不合适的！

---------------------------------------------------------------------------------------------------------------------------------

通过Java Bean直接接收所有请求参数的值

设计一个Java Bean包含所有的请求参数，并且在Java Bean中的属性名与前端页面的表单中使用的名称保持一致，然后，在处理请求的方法中，添加这个Java Bean类型的参数即可使用（类似于以上第2种做法）

public class User {
private String username;
private String password;
private int salary;
// ... Set/Get方法 ...
}
public String handleRegister(User user) {
// 直接使用参数即可，这些参数已经被赋值
}

---------------------------------------------------------------------------------------------------------------------------------

将处理完毕后的数据转发给View组件

通过request封装，然后转发

在处理请求的方法中添加HttpServletRequest参数，在方法中，调用参数的setAttribute()方法将数据封装，由于Spring的处理过程会默认将请求转发到View组件，在则View组件（例如jsp页面）中可以通过EL表达式应用这些数据。

public String handlerRegister(
HttpServletRequest request,
User user) {
// 封装数据，以转发到JSP
request.setAttribute("name", user.getUsername());
// ....
}

以上做法中，转发的行为不需要自己写，Spring会自动完成！

---------------------------------------------------------------------------------------------------------------------------------

使用ModelAndView

在ModelAndView类中有一个Map<String, Object>，如果处理请求的方法是返回ModelAndView对象的，则其中Map将被View组件获取得到！则可以：

String viewName = "user_register_info";
Map<String, Object> data = new HashMap<String, Object>();
data.put("pwd", "123456");
ModelAndView mav = new ModelAndView(

如果方法中已有ModelAndView的对象，也可以：

mav.getModel.put("pwd, "123456");
return mav;

这种做法要求处理请求的方法的返回值必须是ModelAndView类型的！

---------------------------------------------------------------------------------------------------------------------------------

使用ModelMap

这种方式的做法与使用HttpServletRequest几乎一致：先在处理请求的方法中添加ModelMap类型的参数，然后在方法中调用参数的addAttribute()方法封装数据即可！

public String handlerRegister(User user, ModelMap data) {
// 封装数据
data.addAttribute("name", user.getUsername());
// ....
}

虽然这种做法从代码上来看与使用HttpServletRequest是相同的，但是推荐使用这种做法（原因待续）。

---------------------------------------------------------------------------------------------------------------------------------

使用HttpSession

参考第1种做法，当可以使用HttpServletRequest时，调用该对象的getSession()方法即可得到HttpSession对象，也可以参考第1种做法的语法，在方法的参数中声明HttpSession session也是可以的！

注意： 由于Session存在的时间相对略长，所以，不要把所有数据都存在Session中！

5、day05－案例目标：注册

界面

user register form.jsp：注册的表单

user register success.jsp：注册成功（暂定）

error.jsp：操作失败，用于提交操作失败的信息

---------------------------------------------------------------------------------------------------------------------------------

用户信息

Integer id

String username

String password

Integer salary

---------------------------------------------------------------------------------------------------------------------------------

数据库与数据表

数据库：springmvc

数据表：

CREATE TABLE user (
id int auto_increment,
username varchar(16) not null unique,
password varchar(16) not null,
salary int,
primary key(id)
);

程序中需要哪些类

cn.tedu.spring.bean.User

cn.tedu.spring.controller.UserController

cn.tedu.spring.util.DBUtils：释放资源

cn.tedu.spring.dao.IUserDao

-- Integer(id) insert(User user)
-- User findUserByUsername(String username)

cn.tedu.spring.dao.UserDaoImpl

cn.tedu.spring.service.IUserService

-- Integer(id) reg(User user)

cn.tedu.spring.service.UserServiceImpl

cn.tedu.spring.exception.UsernameAlreadyExistsException

---------------------------------------------------------------------------------------------------------------------------------

程序中需要哪些配置

db.properties
<util:properties location="classpath:db.properties" id="dbConfig" />
<bean id="ds" class="......BasicDataSource">
<property name="driverClassName" value="#{dbConfig.???}">
<property name="url" value="#{dbConfig.???}"">
</bean>

开发步骤

1 创建项目DAY05-SpringMVC-Sample，生成web.xml

2 拷贝applicationContext.xml

3 添加依赖：spring-webmvc、commons-dbcp、mysql-conntection-java、junit

4 添加Tomcat Runtime

5 编写数据库配置：db.properties

6 在Spring中配置BasicDataSource的bean，并使用JUnit测试

7 创建数据库与数据表

8 完成难度较低的、作为支撑的JAVA类：User、DBUtils、UsernameAlreadyExistsException

9 编写IUserDao接口，推荐为其中的方法添加文档注释

10 编写UserDaoImpl类，并使用@Component对该类进行注解，自定义Bean ID，在编写UserDaoImpl类中的方法时，强烈推荐记住开发步骤！并且每次完成某个方法后，使用JUnit进行测试！

11 编写IUserService接口，推荐为其中的方法添加文档注释

12 编写UserServiceImpl类，并使用@Component对该类进行注解，自定义Bean ID

如果时间充沛，请设计完成登录！

界面

user register form.jsp：注册的表单

user register success.jsp：注册成功（暂定）

error.jsp：操作失败，用于提示操作失败的信息

用户信息

Integer id

String username

String password

Integer salary

数据库与数据表

数据库：springmvc

数据表：

CREATE TABLE user (
id int auto_increment,
username varchar(16) not null unique,
password varchar(16) not null,
salary int,
primary key(id)
);

程序中需要哪些类

cn.tedu.spring.bean.User

cn.tedu.spring.controller.UserController

cn.tedu.spring.util.DBUtils：释放资源

cn.tedu.spring.dao.IUserDao

-- Integer(id) insert(User user)

-- User findUserByUsername(String username)

cn.tedu.spring.dao.UserDaoImpl

cn.tedu.spring.service.IUserService

-- Integer(id) reg(User user)

cn.tedu.spring.service.UserServiceImpl

cn.tedu.spring.exception.UsernameAlreadyExistsException

---------------------------------------------------------------------------------------------------------------------------------

程序中需要哪些配置

db.properties
<util:properties location="classpath:db.properties" id="dbConfig" />
<bean id="ds" class="......BasicDataSource">
<property name="driverClassName" value="#{dbConfig.???}">
<property name="url" value="#{dbConfig.???}"">
</bean>

开发步骤

1 创建项目DAY05-SpringMVC-Sample，生成web.xml

2 拷贝applicationContext.xml

3 添加依赖：spring-webmvc、commons-dbcp、mysql-conntection-java、junit

4 添加Tomcat Runtime

5 编写数据库配置：db.properties

6 在Spring中配置BasicDataSource的bean，并使用JUnit测试

7 创建数据库与数据表

8 完成难度较低的、作为支撑的JAVA类：User、DBUtils、UsernameAlreadyExistsException

9 编写IUserDao接口，推荐为其中的方法添加文档注释

11 编写IUserService接口，推荐为其中的方法添加文档注释

12 编写UserServiceImpl类，并使用@Component对该类进行注解，自定义Bean ID

13 编写UserController类，并使用@Controller和@RequestMapping("/user")进行注解，然后在该类中添加方法： @RequestMapping("/reg.do") public String showRegisterForm() { } @RequestMapping("/handleRegister.do") public String handleRegister() { }

14 完成对应的JSP页面

---------------------------------------------------------------------------------------------------------------------------------

合理的转发数据

当Controller需要向View组件传递数据时，可以通过转发机制（将数据封装到request或使用ModelAndView或使用ModelMap）或使用Session，通常，标识用户信息的数据和常用数据（在许多页面中都可能需要使用到的）推荐使用Session进行存储，而其它的数据可能只在某次请求时才需要使用，则应该使用转发机制。

---------------------------------------------------------------------------------------------------------------------------------

解决乱码问题

出现乱码的唯一原因：编码不统一！

解决乱码的唯一思路：统一编码！包括：数据库编码、程序源代码编码、传输和处理编码、前端显示编码。

由于使用了SpringMVC后，请求的数据都将先交给DispatcherServlet然后再分发给各个Controller，所以，如果处理数据的编码有问题，在Controller内部使用request.setCharacterEncoding()是不可取的！

在SpringMVC中，已经定义了字符编码过滤器CharacterEncodingFilter，所以，当需要设置字符编码时，只需要在web.xml中配置该过滤器即可！

<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

注意： 只上方式只适用于通过POST方式提交的请求！

---------------------------------------------------------------------------------------------------------------------------------

拦截器：Interceptor

拦截器的作用：对请求进行拦截、判断，最终选择放行或者拦截。

在SpringMVC中，拦截器的第1次会出现在调用Controller的方法之前。

在拦截器中，共有3个抽象方法需要被实现，分别是：preHandle()、postHandle()、afterCompletion()，其中，preHandle()会在调用Controller中的方法之前被执行，该方法返回boolean值，如果返回true，则表示放行，返回false表示拦截，postHandle()和afterCompletion()会在Controller执行结果之后被调用！

---------------------------------------------------------------------------------------------------------------------------------

使用拦截器的步骤

1 自定义拦截器类，实现HandlerInterceptor接口

2 在Spring的配置文件中，添加<mvc:interceptors>节点，进行配置

<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/*" />
<mvc:exclude-mapping path="/login.do"/>
<mvc:exclude-mapping path="/handleLogin.do"/>
<bean class="cn.tedu.spring.interceptor.SessionInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>

什么情况下需要使用拦截器

多个Controller都需要处理的业务，可以使用拦截器来完成！

---------------------------------------------------------------------------------------------------------------------------------

配置拦截器时匹配所有资源

在配置拦截器时，<mvc:mapping path="/ " />中的 / 表示匹配根路径下的所有资源！ 并不表示匹配所有资源！ 例如在这样的配置下，/user/login.do是不受该拦截器影响的！

如果需要匹配所有资源，则需要使用 /**。

---------------------------------------------------------------------------------------------------------------------------------

如何使用拦截器的例外(exclude-mapping)

如果只有少量的例外，则直接配置即可！

如果例外的请求路径较多，则应该重新规划路径的格式，例如把需要拦截的路径规划为 /xyz，则例外的规划为 /xxx，则配置拦截器，只拦截 /xyz 即可。

---------------------------------------------------------------------------------------------------------------------------------

拦截器与过滤器有什么区别

拦截器和过滤器有相似之处，例如同一个Web项目中可以存在多个拦截器，也可以存在多个过滤器，并且，它们在执行时都会行成一条“链”，只要满足请求路径，每个请求都可能导致多个拦截器或多个过滤器被执行！

过滤器是在Servlet之前执行的，而拦截器的首次执行是在Servlet之后、Controller之前。

过滤器是JAVA EE固有的组件，拦截器是Spring MVC的组件。

---------------------------------------------------------------------------------------------------------------------------------

使用拦截器实现判断是否登录

假设存在请求路径：

login.do user_info.do index.do

其中，login.do可以不需要登录即可直接访问，而另2个必须登录后才可以访问，在没有登录之前，如果访问的话，将直接跳转到login.do。

public boolean preHandle(
HttpServletRequest request,
HttpServletResponse response, Object handler)
throws Exception {
// 输出日志
System.out.println("SessionInterceptor.preHandle()");
System.out.println("\targ0=" + request);
System.out.println("\targ1=" + response);
System.out.println("\targ2=" + handler);

// 获取Session
HttpSession session = request.getSession();
// 检查Session
// 例如存在规则：登录后Session中一定有username
if (session.getAttribute("username") == null) {
// Session中没有登录数据，则重定向到登录
response.sendRedirect("login.do");
// 不允许放行，此次请求将被拦截
return false;
} else {
// Session中有登录数据，则正常放行
return true;
}
}

增加一个请求 /handleLogin.do 用于模拟登录并赋予Session信息。

配置拦截器：

<mvc:interceptor>
<mvc:mapping path="/*" />
<mvc:exclude-mapping path="/login.do"/>
<mvc:exclude-mapping path="/handleLogin.do"/>
<bean class="cn.tedu.spring.interceptor.SessionInterceptor" />
</mvc:interceptor>

Spring MVC的异常处理

SimpleMappingExceptionResolver

适用范围：当项目中多处可能出现某种异常，并且解决异常的方式是跳转到指定的View组件时。

SimpleMappingExceptionResolver是一个类，需要在Spring的配置文件中使用节点进行注册。

---------------------------------------------------------------------------------------------------------------------------------

@ExceptionHandler

在Controller内部，自定义处理异常的方法，并使用@ExceptionHandler进行注解！该方法的编写与处理请求的方法类似，然后，在方法的参数中应该添加Exception。

---------------------------------------------------------------------------------------------------------------------------------

两种方式对比

使用SimpleMappingExceptionResolver的配置很简单，但是处理得会比较“粗糙”，很难提示精准的信息，除非异常本身出现的可能就很少！

使用@ExceptionHandler比较自由，处理得可以更加“细致”，但是相对麻烦一些，毕竟每个处理异常的方法只能作用于它所在的Controller类，如果某种异常在多个Controller类中都可能出现，则需要处理多次！

---------------------------------------------------------------------------------------------------------------------------------

Spring MVC的转发与重定向

在Controller的处理请求的方法中，返回的String表示后续负责显示的View组件的名称，默认的方式是转发，例如返回"index"，并且在Spring的配置文件中前缀是"/WEB-INF/jsp/"、后缀是".jsp"，则表示将转发给"/WEB-INF/jsp/index.jsp"。

在使用转发时，也可以添加"path:"作为前缀，即处理请求的方法的返回值可以是"path:index"，等效于"index"。

如果需要重定义，则使用"redirect:"作为前缀即可： @RequestMapping(" handleLogin.do ") public String handleLogin() { // 验证登录，假设是成功的 return "redirect:index"; }

---------------------------------------------------------------------------------------------------------------------------------

注解的驱动

在Spring的配置文件中，在根节点下添加<mvc:annotation-driven />节点用于驱动注解。

7、day07-图

8、day-08-SSM

SSM应用搭建

1.部署Spring + Spring MVC

导入包

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.2.8</version>
</dependency>

<dependency>
<groupId>mysql-connector-java</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.37</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>


<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>

配置Spring MVC的前端控制器web.xml：

<servlet>
<description></description>
<display-name>DispatcherServlet</display-name>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:conf/spring-*.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

Spring配置文件村存在conf文件夹中，并且其文件名符合spring - *。xml规则。

添加数据库连接参数文件conf / db.properties

url=jdbc:mysql://localhost:3306/tedustore
driver=com.mysql.jdbc.Driver
user=root
password=root
initsize=1
maxsize=5

添加数据库连接池配置文件spring-db.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- conf/spring-db.xml 用于管理数据库的连接 -->
<!-- 读取conf/db.properties -->
<util:properties id="dbConfig"
location="classpath:conf/db.properties" />
<!-- 配置DBCP所需的Bean -->
<!-- 各property中的name以类中的set方法名称为准 -->
<bean id="ds"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="#{dbConfig.driver}"/>
<property name="url"
value="#{dbConfig.url}"/>
<property name="username"
value="#{dbConfig.user}"/>
<property name="password"
value="#{dbConfig.password}"/>
<property name="initialSize"
value="#{dbConfig.initsize}"/>
<property name="maxActive"
value="#{dbConfig.maxsize}"/>
</bean>
</beans>

添加Spring MVC配置文件spring-mvc.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- conf/spring-mvc.xml 用于管理MVC的配置 -->
<context:component-scan
base-package="cn.tedu.spring" />
<mvc:annotation-driven/>
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans>

部署测试...

2.部署Spring MyBatis

导入包（略）

添加Spring MyBatis配置文件spring-mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
<!-- conf/spring-mybatis.xml 用于管理MVC的配置 -->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds"/>
<!--
<property name="mapperLocations"
value="classpath:mapping/*.xml"/> -->
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactory"
ref="sqlSessionFactory"/>
<property name="basePackage"
value="cn.tedu.store.dao"/>
</bean>
</beans>

其中mapperLocations属性被临时注释掉了，再以后有映射文件以后打开。

利用JUnit进行离线测试：

public class MyBatisTest {
ClassPathXmlApplicationContext ctx;
@Before
public void init(){
ctx = new ClassPathXmlApplicationContext(
"conf/spring-db.xml",
"conf/spring-mybatis.xml");
}
@Test
public void testSqlSession(){
SqlSessionFactory factory=
ctx.getBean("sqlSessionFactory",
SqlSessionFactory.class);
SqlSession session=factory.openSession();
System.out.println(session);
session.close();
}
}

实现用户列表功能

原理：

数据层

实现步骤：

数据表结构：

desc user;
+-------------+-------------+------+-----+-------------------+-----------------------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+-------------------+-----------------------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| username | varchar(20) | YES | | NULL | |
| password | varchar(30) | YES | | NULL | |
| email | varchar(20) | YES | | NULL | |
| mobile | varchar(20) | YES | | NULL | |
| create_time | timestamp | NO | | CURRENT_TIMESTAMP | on update CURRENT_TIMESTAMP |
+-------------+-------------+------+-----+-------------------+-----------------------------+

添加实体类用户

public class User implements Serializable {
private static final long serialVersionUID = -7291170424207323214L;
private Integer id;
private String username;
private String password;
private String mobile;
private String email;
private Date createTime;
public User() {
}
public User(Integer id, String username, String password, String mobile, String email, Date createTime) {
super();
this.id = id;
this.username = username;
this.password = password;
this.mobile = mobile;
this.email = email;
this.createTime = createTime;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", password=" + password + ", mobile=" + mobile
+ ", email=" + email + ", createTime=" + createTime + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}

声明道接口

public interface UserDao {
/**
* 查询全部的用户信息
* @return 用户信息列表
*/
List<User> findAllUsers();
}

添加映射配置文件mapping / userMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.tedu.store.dao.UserDao">
<!-- mapping/userMapper.xml 映射文件 -->
<!--
result: 结果
parameter: 参数
type: 类型
resultType: 用于声明方法的返回结果元素的类型
parameterType: 参数的类型，当方法只有一个参数时候使用！
如果有更多个参数建议使用 @Param 注解标注
-->
<select id="findAllUsers"
resultType="cn.tedu.store.bean.User">
select
id,
username,
password,
mobile,
email,
create_time as createTime
from
user
</select>
</mapper>

更新db.properties

url=jdbc:mysql://localhost:3306/tedustore

更新spring-mybatis.xml

<property name="mapperLocations"
value="classpath:mapping/*.xml"/>

利用JUnit的进行离线测试

public class UserDaoTest {
ClassPathXmlApplicationContext ctx;
UserDao dao;
@Before //在全部测试案例之前执行的方法
public void init(){
ctx = new ClassPathXmlApplicationContext(
"conf/spring-db.xml",
"conf/spring-mybatis.xml");
dao = ctx.getBean("userDao",UserDao.class);
}
@After //全部测试案例执行之后执行 destory方法
public void destory(){
ctx.close();
}
@Test
public void testFindAllUsers(){
List<User> list=dao.findAllUsers();
for (User user : list) {
System.out.println(user);
}
}
}