mysql 和org.springframework.boot 版本关系 springboot与mybatis的区别

一、Springboot

SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

SpringBoot所具备的特征有：

（1）可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；

（2）内嵌Tomcat或Jetty等Servlet容器；

（3）提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；

（4）尽可能自动配置Spring容器；

（5）提供准备好的特性，如指标、健康检查和外部化配置；

（6）绝对没有代码生成，不需要XML配置。

二、Mybatis

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。

• 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件。易于学习，易于使用。通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的orm字段关系映射。
• 提供对象关系映射标签，支持对象关系组建维护。
• 提供xml标签，支持编写动态sql。

三、项目创建

1. 选择左侧的Spring Initializr，jdk要求1.8及以上，选择默认的Default下一步：

3. 自己修改项目名，后选择下一步：



5. 选择项目所需要的依赖，这个页面是选择你工程中需要用到的依赖，因为我们的目标是web项目使用mybatis所以在web模块中勾选Spring Web，在SQL中依次勾选Jdbc API、Mybatis Framework、Mysql Driver。然后下一步直到finish即可。



6. 
   



7. 
   



8. 接着项目就会下载我们需要的依赖，如果之前没有下过，可能会稍等几分钟。
9. 生成的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>studentadmin</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>studentadmin</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.example.StudentadminApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

6. 创建如下目录及文件

四、代码实现

1. stuController

@RestController
@RequestMapping("/StuAdmin")
public class StuController {
    @Autowired
    private StuService stuService;
    @Autowired
    private CouService couService;

    public StuController() {
    }
    @GetMapping("/{key}")
    public List<Student> show(@PathVariable String key){
        return stuService.show(key);
    }
    @GetMapping("/")
    public List<Student> show(){
        String key="";
        return stuService.show(key);
    }
    @PostMapping("/add")
    public boolean add(@RequestParam("student") String student,
                        @RequestParam("courses") String course){
        Gson gson=new Gson();
        Student s =gson.fromJson(student,Student.class);
        List<Course> c= gson.fromJson(course, new TypeToken<List<Course>>() {}.getType());
        if(c.isEmpty()){
            if(stuService.add(s)>=1)
                return true;
        }
        else {
            if (stuService.add(s) >= 1 && couService.add(s.getNo(), c) >= 1)
                return true;
        }
        return false;
    }
    @GetMapping("/delete")
    public boolean delete(@RequestParam("no") String no){
        System.out.println(no);
        if(couService.showsel(no).size()==0) {
            if (stuService.delete(no) >= 1) {
                return true;
            }
            else
                return false;
        }
        else
            return false;
    }
    @PostMapping("/update")
    public boolean update(@RequestParam("student") String student,
                          @RequestParam("courses") String course){
        Gson gson=new Gson();
        Student s =gson.fromJson(student,Student.class);
        List<Course> c= gson.fromJson(course, new TypeToken<List<Course>>() {}.getType());
        if(c.isEmpty()){
            if(stuService.update(s)>=1) {
                couService.delete(s.getNo());
                return true;
            }
        }
        else {
            if (stuService.update(s) >= 1 ) {
                couService.update(s.getNo(), c);
                return true;
            }
        }
        return false;
    }

    @GetMapping("/Course")
    public List<Course> couShow(){
        //System.out.println("查询课程");
        return couService.show();
    }
    @GetMapping("/cousel/{no}")
    public List<Course> couSelShow(@PathVariable String no){
        return couService.showsel(no);
    }
}

2. stuMapper.xml
   基于Mybatis实现数据库Mysql的访问

<?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.example.mapper.StuMapper">

    <resultMap id="BaseResultMap" type="com.example.bean.Student">
        <result column="no" jdbcType="VARCHAR" property="no" />
        <result column="name" jdbcType="VARCHAR" property="name" />
        <result column="age" jdbcType="INTEGER" property="age" />
        <result column="sex" jdbcType="VARCHAR" property="sex" />
        <result column="college" jdbcType="VARCHAR" property="college" />
        <result column="major" jdbcType="INTEGER" property="major" />
        <result column="enrollment_date" jdbcType="VARCHAR" property="enrollment_date" />
    </resultMap>

    <select id="show" resultType="com.example.bean.Student">
        select * from student where name like "%"#{key}"%" or major like "%"#{key}"%"
    </select>
    <insert  id="add" parameterType="com.example.bean.Student" >
        insert into student(no,name,age,sex,college,major,enrollment_date) VALUES (#{no},#{name},#{age},#{sex},#{college},#{major},#{enrollment_date})
    </insert>
    <delete  id="delete" parameterType="String" >
        delete from student where no=#{no}
    </delete>
    <update id="update" parameterType="com.example.bean.Student">
        update student set no=#{no},name=#{name},age=#{age},sex=#{sex},college=#{college},major=#{major},enrollment_date=#{enrollment_date} where no=#{no}
    </update>
</mapper>

五、数据库

数据库中所有表

选取部分即选课表的设计

六、android端

使用android开发相应的app来显示学生信息，实现学生管理系统各项功能

android 端到后端数据访问使用的是OkHttpUtils完成前端到后端数据交互。
OkHttpUtils
封装了okhttp的网络框架，支持大文件上传下载，上传进度回调，下载进度回调，表单上传（多文件和多参数一起上传），链式调用，可以自定义返回对象，支持Https和自签名证书，支持cookie自动管理，支持四种缓存模式缓存网络数据，支持301、302重定向，扩展了统一的上传管理和下载管理功能
需要添加的依赖

implementation 'com.squareup.okhttp:okhttp:2.7.5'
    implementation 'com.squareup.okio:okio:3.0.0-alpha.1'
    implementation 'com.zhy:okhttputils:2.0.0'

数据请求

OkHttpUtils.get()
               .url("http://ip地址:8001/StuAdmin/"+key)
               .build()
               .connTimeOut(20000)
               .readTimeOut(20000)
               .writeTimeOut(20000)
               .execute( new StringCallback(){
                   @Override
                   public void onError(Request request, Exception e) {       
                   }
                   @Override
                   public void onResponse(String  response) {                 
                   }
               });

七、效果

八、总结

使用springboot非常方便，配置变得简单了，springboot内嵌了servlet容器，降低了对环境的要求，机器有java运行环境，可以将项目打包成jar包，
Mybatis是一个半自动的ORM持久层框架，内部封装了JDBC。作为开发者只需要关注sql语句本身。Mybatis是通过xml或注解的方式将需要执行的各种statement配置起来。通过Java对象和statement中的sql动态参数映射生成最终执行的sql语句，最终由Mabtais框架执行sql并将结果映射为Java对象并返回。MyBatis 支持定制化 SQL、存储过程以及高级映射。MyBatis 是可以双向映射的，可以将数据集映射为Java对象，也可以将Java对象映射为数据库中的记录。
同时本次实验还是使用到了okhttp,相比于使用httpclient，okhttp的封装，使得网络访问更加简单、方便，易于操作，数据获取更加简单。