基于SSM框架实现省市区3级联查

向右看齐 2021-09-17 03:22 570阅读 0赞

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

作者：乔你那熊色  
来源：CSDN  
原文：[https://blog.csdn.net/qq\_41160264/article/details/82810128][https_blog.csdn.net_qq_41160264_article_details_82810128]

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

下面我们就以代码的形式来说一下这个省市区3级联查是如何实现的。

### ***一.Spring的核心配置文件*** ###

我们知道Spring的核心配置文件applicationContext通常放在src目录下，下面就是applicationContext.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:jee= "http://www.springframework.org/schema/jee" 
       xmlns:tx= "http://www.springframework.org/schema/tx" xmlns:aop= "http://www.springframework.org/schema/aop" 
       xmlns:p= "http://www.springframework.org/schema/p" xmlns:util= "http://www.springframework.org/schema/util" 
       xmlns:tool= "http://www.springframework.org/schema/tool" xmlns:context= "http://www.springframework.org/schema/context" 
       xsi:schemaLocation= "http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx.xsd 
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop.xsd 
       http://www.springframework.org/schema/jee 
       http://www.springframework.org/schema/jee/spring-jee.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util.xsd 
       http://www.springframework.org/schema/tool 
       http://www.springframework.org/schema/tool/spring-tool.xsd" 
       
       default-lazy-init= "false" default-autowire= "byName"> 
       
        
       <bean id="basicDataSource" class="org.apache.commons.dbcp.BasicDataSource"> 
        
       <property name="driverClassName" value="com.mysql.jdbc.Driver"> </property> 
       <property name="url" value="jdbc:mysql://localhost:3306/ssmltl"> </property> 
       <property name="username" value="root"> </property> 
       <property name="password" value="root"> </property> 
       </bean> 
       
        
       <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean"> 
        
       <property name="dataSource" ref="basicDataSource"> </property> 
       <property name="configLocation" value="classpath:mybatis.cfg.xml"> </property> 
       </bean> 
       
        
       <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        
       <property name="dataSource" ref="basicDataSource"/> 
       </bean> 
       
        
       <tx:advice id="txAdvice" transaction-manager="txManager"> 
       <tx:attributes> 
       <tx:method name="get*" read-only="true" /> 
       <tx:method name="find*" read-only="true" /> 
       <tx:method name="load*" read-only="true" /> 
       <tx:method name="select*" read-only="true" /> 
       <tx:method name="add*" propagation="REQUIRED" /> 
       <tx:method name="save*" propagation="REQUIRED" /> 
       <tx:method name="update*" propagation="REQUIRED" /> 
       <tx:method name="del*" propagation="REQUIRED" /> 
       </tx:attributes> 
       </tx:advice> 
       
        
       <aop:config proxy-target-class="true"> 
        
       <aop:pointcut id="serviceMethod" expression="execution(* service.*.*(..))"/> 
        
       <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod" /> 
       </aop:config> 
       
        
       <context:annotation-config/> 
       <context:component-scan base-package="com.java"/> 
       
       
        
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       </beans>

在这段代码中，我们配置了数据源，配置要操作数据库的sessionFactory。并且在配置sessionFactory时，指定了sessionFactory操作的数据库和操作数据库的方法。

我们也在该文件中配置了事务管理器，用来进行事务管理。配置事务管理器的时候，指定了事务要操作的数据库。

下面我们来看一下配置事务时，<tx:advice>标签的作用：

![70][]

我们在<tx:method>标签中，配置了name值，说明为哪一类方法实现了事务管理。 propagation="REQUIRED"代表支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。其中\*为通配符，即代表以select为开头的所有方法，即表示符合此命名规则的方法作为一个事务。

在配置切面的切点的过程中，切点的作用是为满足条件的所有方法开启事务，但是没有是实现事务，实现事务需要用<tx:method>标签来指明。expression="execution(\* service.\*.\*(..))"  的作用是：service包下的作用类的作用方法（不限返回值类型和方法的参数个数）开启事务。第一个 \* 通配符： 任意返回值类型；第二个 \* 通配符： 包service  下的任意class；第三个 \* 通配符：包service下的任意class的任意方法；第四个 .. ：方法可以有0个或多个参数。

当然了，我们需要在该文件中扫描所需要的包，发挥注解的作用 ，进行属性注入。

### ***二.Mybatis的核心配置文件*** ###

mybatis的核心配置文件的位置和名称不是固定的，因为在applicationContext.xml需要引入这个文件，我们只需要把mybatis的核心配置文件路径给applicationContext.xml即可。但是我们通常将它放在src目录下，命名为mybatis.cfg.xml。

<?xml version="1.0" encoding="UTF-8" ?> 
       <!DOCTYPE configuration 
       PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
       "http://mybatis.org/dtd/mybatis-3-config.dtd"> 
       
       
       
       <configuration> 
        
       <mappers> 
       <mapper resource="com/java/entity/ProvinceMapper.xml"> </mapper> 
       </mappers> 
       </configuration>

在该文件中，我们只引入了mapper.xml，这个文件我们可以认为是操作数据库的方法（sql语句）。

### ***三.springMVC的核心配置文件*** ###

springMVC的核心配置文件的文件名和存放位置我们也可以自定义，因为这个容器是有web容器进行加载的，我们只需要在web容器中指定做需要加载的  springMVC的核心配置文件的路径即可。但是我们通常将它放在src目录下，命名为springmvc-servlet.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:aop= "http://www.springframework.org/schema/aop" 
       xmlns:c= "http://www.springframework.org/schema/c" xmlns:mvc= "http://www.springframework.org/schema/mvc" 
       xmlns:p= "http://www.springframework.org/schema/p" xmlns:tx= "http://www.springframework.org/schema/tx" 
       xmlns:util= "http://www.springframework.org/schema/util" xmlns:context= "http://www.springframework.org/schema/context" 
       xsi:schemaLocation= "http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd 
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd 
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd 
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 
       
       
        
       
        
       
        
       <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> 
       <property name="defaultEncoding" value="utf-8"> </property> 
       <property name="maxUploadSize" value="10485760000"> </property> 
       <property name="maxInMemorySize" value="40960"> </property> 
       </bean> 
       
        
       <bean id="stringConverter" class="org.springframework.http.converter.StringHttpMessageConverter"> 
       <property name="supportedMediaTypes"> 
       <list> 
       <value>text/plain;charset=UTF-8 </value> 
       </list> 
       </property> 
       </bean> 
       
       <bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> </bean> 
       <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
       <property name="messageConverters"> 
       <list> 
       <ref bean="stringConverter"/> 
       <ref bean="jsonConverter"/> 
       </list> 
       </property> 
       </bean> 
       
        
       
        
       <context:component-scan base-package="com.java.Controller"/> 
       
       </beans>

在这里最重要的就是配置了 用于将对象转为JSON  的功能（JSON转换器）。我们需要导入 jackson-annotations-\*.jar , jackson-core-.jar , jackson-databind-.jar。

### ***四.web.xml*** ###

上述的spring的核心配置文件和springmvc的核心配置文件之所以位置和名称可以自定义，就是因为在web.xml中已经指定了这两个文件所在的位置，关于这个文件，代码如下：

<?xml version="1.0" encoding="UTF-8"?> 
       <web-app version="2.5" 
       xmlns= "http://java.sun.com/xml/ns/javaee" 
       xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation= "http://java.sun.com/xml/ns/javaee 
       http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> 
       
       
        
       <context-param> 
       <param-name>contextConfigLocation </param-name> 
       <param-value>classpath:applicationContext.xml </param-value> 
       </context-param> 
       
       <listener> 
       <listener-class>org.springframework.web.context.ContextLoaderListener </listener-class> 
       </listener> 
       
       <servlet> 
       <servlet-name>DisplayChart </servlet-name> 
       <servlet-class> 
       org.jfree.chart.servlet.DisplayChart  
       </servlet-class> 
       </servlet> 
       
       <servlet-mapping> 
       <servlet-name>DisplayChart </servlet-name> 
       <url-pattern>/DisplayChart </url-pattern> 
       </servlet-mapping> 
       
       <servlet> 
       <servlet-name>springmvc </servlet-name> 
       <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class> 
       
        
       <init-param> 
       <param-name>contextConfigLocation </param-name> 
       <param-value>classpath:springmvc-servlet.xml </param-value> 
       </init-param> 
       <load-on-startup>1 </load-on-startup> 
       </servlet> 
       
       <servlet-mapping> 
       <servlet-name>springmvc </servlet-name> 
       <url-pattern>*.action </url-pattern> 
       </servlet-mapping> 
       
       
        
       <filter> 
       <filter-name>encodingFilter </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> 
       <init-param> 
       <param-name>forceEncoding </param-name> 
       <param-value>true </param-value> 
       </init-param> 
       </filter> 
       <filter-mapping> 
       <filter-name>encodingFilter </filter-name> 
       <url-pattern>/* </url-pattern> 
       </filter-mapping> 
        
       
       
       <welcome-file-list> 
       <welcome-file>index.jsp </welcome-file> 
       </welcome-file-list> 
       </web-app>

### ***五.index.jsp*** ###

在配置文件完成后，我们就可以着手功能代码了。我们先来介绍一下index.jsp，也就是用来显示3级联查的页面。

<%@ page language="java" import="com.java.utils.*" pageEncoding="UTF-8"%> 
       <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
       <% 
       String path = request.getContextPath(); 
       String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; 
       System.out.println(basePath); 
       %> 
       
       <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 
       <html> 
       <head> 
        
       <script type="text/javascript" src="js/jquery-1.11.0.min.js"> </script> 
       <title>My JSP 'index.jsp' starting page </title> 
       <meta http-equiv="pragma" content="no-cache"> 
       <meta http-equiv="cache-control" content="no-cache"> 
       <meta http-equiv="expires" content="0"> 
       <meta http-equiv="keywords" content="keyword1,keyword2,keyword3"> 
       <meta http-equiv="description" content="This is my page"> 
       
        
       
       <script type="text/javascript"> 
       
       function show_1(){ 
       $.ajax({ 
       url: 'province/selectAll.action', 
       type: 'post', 
       data:{ 'typeId': 0}, 
       dataType: 'json', 
       //成功回调函数的参数data是一个json数组，长度是json数组里面的对象的个数。 
       success: function(data){ 
       /* 
       alert(data); 
       alert(JSON.stringify(data)); 
       */ 
       console.log( JSON.stringify(data)); 
       console.log(data.length); 
       var t= "<option value='0'>----请选择省----</option>"; 
       for( var i= 0;i<data.length;i++){ 
       t+= "<option value="+data[i].provinceId+ ">"+data[i].provinceName+ "</option>"; 
       //<option value=1>liaoning</option><option value=1>heilongjiang</option> 
       } 
       $( "#p").html(t); 
       } 
       }) 
       
       } 
       function show_2(){ 
       
       var provinceId=$( "#p").val(); 
       $.ajax({ 
       url: 'province/selectAllCity.action', 
       type: 'post', 
       data:{ 'provinceId':provinceId}, 
       dataType: 'json', 
       success: function(data){ 
       var t= "<option value='0'>----请选择城市----</option>"; 
       for( var i= 0;i<data.length;i++){ 
       t+= "<option value="+data[i].cityId+ ">"+data[i].cityName+ "</option>" 
       } 
       $( "#c").html(t); 
       }, 
       error: function(data){ 
       alert( "查询城市失败了！"); 
       } 
       }) 
       
       } 
       
       function show_3(){ 
       
       var cityId=$( "#c").val(); 
       $.ajax({ 
       url: 'province/selectAllArea.action', 
       type: 'post', 
       data:{ "cityId":cityId}, 
       dataType: 'json', 
       success: function(data){ 
       alert(data); 
       console.log( JSON.stringify(data)); 
       var t= "<option value='0'>----请选择市区----</option>"; 
       for( var i= 0;i<data.length;i++){ 
       t+= "<option value="+data[i].areaId+ ">"+data[i].areaName+ "</option>" 
       } 
       $( "#a").html(t); 
       } 
       }) 
       
       } 
       
       
       function text_1(){ 
       $.ajax({ 
       url: 'TextResponseBody/text.action', 
       type: 'post', 
       dataType: 'json', 
       success: function(data){ 
       /* 
       alert(data); 
       alert(JSON.stringify(data)); 
       */ 
       console.log( JSON.stringify(data)); 
       console.log(data.length); 
       var t= "<option value='0'>----请选择省----</option>"; 
       for( var i= 0;i<data.length;i++){ 
       t+= "<option value="+data[i].provinceId+ ">"+data[i].provinceName+ "</option>"; 
       //<option value=1>liaoning</option><option value=1>heilongjiang</option> 
       } 
       $( "#p").html(t); 
       } 
       }) 
       
       } 
       </script> 
       </head> 
       
        
       <body onload="show_1()"> 
        
       <select id="p" onchange="show_2()"> </select> 
       <select id="c" onchange="show_3()"> <option value='0'>----请选择城市---- </option> </select> 
       <select id="a" > <option value='0'>----请选择市区---- </option> </select> 
       </body> 
       </html>

要想使用ajax，那么必须要导入jquery.js文件。里面定义了3个show方法，这3个方法分别查询数据库中的省，市，区。我们通过字符串的拼接（包括标签），然后将所拼接的字符串通过html方法放到所需要的标签中来显示信息。

在这个文件中，在body标签中有一个onload="show\_1()"属性，这个属性的作用是当页面加载完成后，自动执行js中的函数show\_1()方法，它和$(function()\{  \}); 的作用是相似的。

在select标签中还有一个onchange（）方法。onchange（）方法的作用是当这个属性所在的标签发生改变时，就会执行这个方法中的js函数。例如select标签，我们选中不同的元素时，那么select标签的value值发生改变，就会执行对应的函数。有如：让input输入框中有这个标签时，只要输入框中的值发生改变时，那么就会执行onchange（）方法中的js函数。

在这个文件中，成功回调函数接收到的是一个json数组。我们如果直接alert（data），那么提示的会是多个Object类型的数据，我们可以通过JSON.stringify(data)方法来将数据进行解析，然后通过console.log()方法，就可以将数据打印到前台控制台。                                                                   我们可以看到有这么一行代码：String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"；

输出basePath我们可以得到：[http://localhost:8080/SSMLTL/][http_localhost_8080_SSMLTL]。通过打印我们可以知道，request.getScheme()可以得到请求该页面用到的协议。request.getServerName()可以得到请求的主机名。request.getServerPort()可以得到请求的端口号。而path就是我们已经得到的项目名。注意path得到的是  /+项目名，所以端口号和path拼接的时候，不用在拼接 “/”。

### ***六.Controller*** ###

我们通过url 访问指定的Controller的指定方法。

package com.java.Controller; 
       
       import java.util.ArrayList; 
       import java.util.List; 
       import java.util.Map; 
       
       import javax.servlet.http.HttpServletRequest; 
       import javax.servlet.http.HttpServletResponse; 
       
       import org.springframework.beans.factory.annotation.Autowired; 
       import org.springframework.stereotype.Controller; 
       import org.springframework.web.bind.annotation.RequestMapping; 
       import org.springframework.web.bind.annotation.RequestParam; 
       import org.springframework.web.bind.annotation.ResponseBody; 
       
       import com.java.service.ProvinceService; 
       import com.java.utils.ToJson; 
       
       @Controller 
       @RequestMapping( "/province") 
       public class ProvinceController { 
       //将service对象注入到controller中 
       @Autowired 
       private ProvinceService provinceService; 
       
       public ProvinceService getProvinceService() { 
       return provinceService; 
       } 
       //通过注解注入好像有没有set方法都可以？ 
       public void setProvinceService(ProvinceService provinceService) { 
       this.provinceService = provinceService; 
       } 
       
       @RequestMapping( "/selectAll") 
       @ResponseBody 
       //挑选全部的省份信息 
       public void selectAll(HttpServletRequest request,HttpServletResponse response, 
       @RequestParam("typeId") int typeId) { 
       List<Map<String, Object>> list= new ArrayList<Map<String, Object>>(); 
       try { 
       list=provinceService.selectAll(typeId); 
       } catch (Exception e) { 
       e.printStackTrace(); 
       } 
       ToJson.toJson(list, request, response); 
       } 
       
       @RequestMapping( "/selectAllCity") 
       @ResponseBody 
       //挑选全部的城市信息 
       public void selectAllCity(HttpServletRequest request,HttpServletResponse response, 
       @RequestParam("provinceId") int provinceId) { 
       List<Map<String, Object>> list= new ArrayList<Map<String, Object>>(); 
       try { 
       list=provinceService.selectAllCity(provinceId); 
       } catch (Exception e) { 
       e.printStackTrace(); 
       } 
       ToJson.toJson(list, request, response); 
       } 
       
       @RequestMapping( "/selectAllArea") 
       @ResponseBody 
       //挑选全部的区信息 
       public void selectAllArea(HttpServletRequest request,HttpServletResponse response, 
       @RequestParam("cityId") int cityId) { 
       List<Map<String, Object>> list= new ArrayList<Map<String, Object>>(); 
       try { 
       list=provinceService.selectAllArea(cityId); 
       } catch (Exception e) { 
       e.printStackTrace(); 
       } 
       System.out.println(list); 
       ToJson.toJson(list, request, response); 
       } 
       
       
       //============================================================================================== 
       public static void main(String[] args) { 
       ProvinceController a= new ProvinceController(); 
       a.selectAll( null, null, 3); 
       } 
       /*hou:[{areaName=和平区, areaId=1}, {areaName=铁西区, areaId=2}, {areaName=沈河区, areaId=3}] 
       
       qian:[{"areaId":1,"areaName":"和平区"},{"areaId":2,"areaName":"铁西区"},{"areaId":3,"areaName":"沈河区"}] 
       * */ 
       }

@RequestMapping注解括号内的值就是我们要访问的路径。通过  @RequestParam 来将前台对应的参数给方法参数。 @ResponseBody  一会我转发一篇博客，那么将会有详细介绍。

这里用到了一个toJson工具方法，代码如下：

package com.java.utils; 
       
       import java.io.PrintWriter; 
       import java.util.ArrayList; 
       import java.util.List; 
       
       import javax.servlet.http.HttpServletRequest; 
       import javax.servlet.http.HttpServletResponse; 
       
       import com.alibaba.fastjson.JSON; 
       
       public class ToJson { 
       
       
       /** 
       * 方法功能：将对象转换成JSON字符串，并响应回前台 
       * 参数：object,request,response 
       * 返回值：void 
       * 异常：IOException 
       */ 
       public static void toJson(Object object,HttpServletRequest request,HttpServletResponse response) { 
       
       //Object 类型可以接收list集合，集合也是一个对象，对象拥有类型，Object是所有类型的父类。 
       Object obj= new ArrayList(); 
       
       /*PrintWriter打印字符流、用于将各种java数据一字符串的形式打印到底层字符输出流中 
       * */ 
       PrintWriter out = null; 
       try { 
       //JSON.toJSONStringWithDateFormat用于序列化信息。 
       String json = JSON.toJSONStringWithDateFormat(object, "yyyy-MM-dd HH:mm:ss"); 
       
       /*response.setContentType(MIME)的作用是使客户端浏览器，区分不同种类的数据，并根据不同的MIME调用浏览 
       *器内不同的程序嵌入模块来处理相应的数据。例如web浏览器就是通过MIME类型来判断文件是GIF图片。通过MIME类型来处 
       *理json字符串。 
       * */ 
       response.setContentType( "text/html;charset=utf-8"); 
       //得到一个打印字符输出流 
       out = response.getWriter(); 
       //[{"areaId":1,"areaName":"和平区"},{"areaId":2,"areaName":"铁西区"},{"areaId":3,"areaName":"沈河区"}] 
       System.out.println(json); 
       //要通过字符输出流来向前台输出数据 
       out.write(json); 
       out.flush(); 
       } catch (Exception e) { 
       e.printStackTrace(); 
       } finally { 
       if (out != null) { 
       out.close(); 
       } 
       } 
       } 
       }

这个小Demo是我从网上下的，然后自己重新写了一遍，做了一点更改，也将自己不懂的记录起来。这里看到一个集合容器竟然用Object类型来接收，心想，一个容器怎么可以用对象类型来接收呢？后来又一想：集合也是一个对象，是对象就拥有类型，而Object是所有类型的父类，所以能接收。

PrintWriter打印字符流，用于将各种java数据 —— 字符串的形式打印到底层字符输出流中。

response.setContentType(MIME)的作用是使客户端浏览器，区分不同种类的数据，并根据不同的MIME调用浏览器内不同的程序嵌入模块来处理相应的数据。例如web浏览器就是通过MIME类型来判断文件是GIF图片。通过MIME类型来处理json字符串。  而MIME类型简单来说就是文本数据的类型。

在传数据的时候，传进来的是一个list集合，其中是对象，但是经过：

String json = JSON.toJSONStringWithDateFormat(object, "yyyy-MM-dd HH:mm:ss");

这行代码，这个对象集合就变成了Json对象数组。这里有有点不理解，既然这能做到，那在spring中配置Json转换器还有什么用？没有它同样可以将对象集合就变成了Json对象数组。

通过write（）方法来向前台返回数据。

### ***七.Service*** ###

下面是service实现类部分代码，service接口这里就省略不写了。

package com.java.service; 
       
       import java.util.List; 
       import java.util.Map; 
       
       import org.springframework.beans.factory.annotation.Autowired; 
       import org.springframework.stereotype.Service; 
       import com.java.dao.ProvinceDao; 
       
       @Service( "/provinceService") 
       public class ProvinceServiceImpl implements ProvinceService { 
       
       @Autowired 
       private ProvinceDao provinceDao; 
       
       public ProvinceDao getProvinceDao() { 
       return provinceDao; 
       } 
       
       public void setProvinceDao(ProvinceDao provinceDao) { 
       this.provinceDao = provinceDao; 
       } 
       
       //挑选全部的省份信息 
       @Override 
       public List<Map<String, Object>> selectAll( int typeId) { 
       
       List<Map<String, Object>> list=provinceDao.selectAll(typeId); 
       return list; 
       } 
       //挑选全部的城市信息 
       @Override 
       public List<Map<String, Object>> selectAllCity( int provinceId) { 
       List<Map<String, Object>> list=provinceDao.selectAllCity(provinceId); 
       return list; 
       } 
       //挑选全部的地区信息 
       @Override 
       public List<Map<String, Object>> selectAllArea( int cityId) { 
       List<Map<String, Object>> list=provinceDao.selectAllArea(cityId); 
       return list; 
       } 
       
       }

###   ***八.dao*** ###

这里呢，我们不适用代理的方式，我们直接实现dao接口，编写它的实现类。下面是dao实现类的代码，同样的dao接口这里我们也省略不贴代码了。

package com.java.dao; 
       
       import java.util.List; 
       import java.util.Map; 
       
       import org.apache.ibatis.session.SqlSession; 
       import org.apache.ibatis.session.SqlSessionFactory; 
       import org.springframework.beans.factory.annotation.Autowired; 
       import org.springframework.stereotype.Repository; 
       
       @Repository( "/provinceDao") 
       public class ProvinceDaoImpl implements ProvinceDao{ 
       
       @Autowired 
       private SqlSessionFactory sqlSessionFactory; //因为采用mybatis所以SqlSessionFactory 
       
       public SqlSessionFactory getSqlSessionFactory() { 
       return sqlSessionFactory; 
       } 
       
       //通过sqlSessionFactory工厂来获得操作数据库的sqlSession对象 
       public SqlSession getSqlSession(){ 
       return sqlSessionFactory.openSession(); 
       } 
       
       public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) { 
       this.sqlSessionFactory = sqlSessionFactory; 
       } 
       
       //挑选全部的省份信息 
       @Override 
       public List<Map<String, Object>> selectAll( int typeId) { 
       SqlSession sqlSession= this.getSqlSession(); 
       //通过sqlSession来调用框架自带的方法查询 
       List<Map<String, Object>> list=sqlSession.selectList( "selectAll",typeId); 
       return list; 
       } 
       //挑选全部的城市信息 
       @Override 
       public List<Map<String, Object>> selectAllCity( int provinceId) { 
       SqlSession sqlSession= this.getSqlSession(); 
       List<Map<String, Object>> list=sqlSession.selectList( "selectAllCity",provinceId); 
       return list; 
       } 
       //挑选全部的地区信息 
       @Override 
       public List<Map<String, Object>> selectAllArea( int cityId) { 
       SqlSession sqlSession= this.getSqlSession(); 
       List<Map<String, Object>> list=sqlSession.selectList( "selectAllArea",cityId); 
       return list; 
       } 
       
       }

### ***九.Mapper.xml*** ###

我们已经通过sqlSession调用方法来查询数据库，那么我们就需要在mapper中定义查询数据库的sql语句，并且这个sql语句所在标签的id 值要和daoImpl中的索引值一致。

<?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="com.java.entity.Province"> 
        
        
        
       <select id="selectAll" parameterType="int" resultType="com.java.entity.Province"> 
       select provinceId,provinceName from t_province 
       </select> 
       
        
       <select id="selectAllCity" parameterType="int" resultType="java.util.Map"> 
       select cityId,cityName from t_city where provinceId=#{provinceId} 
       </select> 
       
        
       <select id="selectAllArea" parameterType="int" resultType="java.util.Map" > 
       select areaId,areaName from t_area where cityId=#{cityId} 
       </select> 
       
       </mapper>

每回namespace中我们写的都是dao接口的权限定名，但是这次却写什么都可以，因为我们已经实现了dao接口，所以namespace我们可以把它当做命名空间。如果不同的mapper.xml文件中，有相同的id值标签怎么办？那么在查询的时候，就会发生异常，因为jvm不知道执行哪一个标签的sql语句。我百度了一下，想既然你模棱两可不知道用哪个sql语句，那我把namespace加上，通过namespace+id的形式不就可以指定执行哪一个sql了？很遗憾，我们找到书写语法。。。。。。。。

### ***十.数据库*** ###

最后贴一下数据库的截图。

![70 1][]

\------------

![70 2][]

\-------------------------

![70 3][]\-

\------------------------

![70 4][]

\----------------------

这个数据库建的属实很简单，为了测试吗，见谅。。。。。。。

对了，还有一个实体类，也顺便贴上吧：

package com.java.entity; 
       
       public class Province { 
       //省所需属性 
       private int provinceId; 
       private String provinceName; 
       
       public int getProvinceId() { 
       return provinceId; 
       } 
       public void setProvinceId(int provinceId) { 
       this.provinceId = provinceId; 
       } 
       public String getProvinceName() { 
       return provinceName; 
       } 
       public void setProvinceName(String provinceName) { 
       this.provinceName = provinceName; 
       } 
       
       //------------------------------------- 
       
       /*市所需属性 
       private int cityId; 
       private String cityName; 
       
       public int getCityId() { 
       return cityId; 
       } 
       public void setCityId(int cityId) { 
       this.cityId = cityId; 
       } 
       public String getCityName() { 
       return cityName; 
       } 
       public void setCityName(String cityName) { 
       this.cityName = cityName; 
       } 
       */ 
       //------------------------------------ 
       /*区所需属性 
       private int areaId; 
       private String areaName; 
       
       public int getAreaId() { 
       return areaId; 
       } 
       public void setAreaId(int areaId) { 
       this.areaId = areaId; 
       } 
       public String getAreaName() { 
       return areaName; 
       } 
       public void setAreaName(String areaName) { 
       this.areaName = areaName; 
       } 
       
       */ 
       
       }

[https_blog.csdn.net_qq_41160264_article_details_82810128]: https://blog.csdn.net/qq_41160264/article/details/82810128
[70]: /images/20210720/8d22fbb143e14688aeacfe8543dc7729.png
[http_localhost_8080_SSMLTL]: http://localhost:8080/SSMLTL/
[70 1]: /images/20210720/6ce436eca19a4e558c46d17420d12648.png
[70 2]: /images/20210720/83a6dc4142344c4fb6077e9c0fedc4e2.png
[70 3]: /images/20210720/55b218852cf043f0b1b757cab2f0dcd8.png
[70 4]: /images/20210720/18138d1dabd642dca658c465cc42ec55.png