zoukankan html css js c++ java

SpringBoot入门学习以及整合MyBatis

1. Spring Boot简介

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

SpringBoot是伴随着Spring4.0诞生的；

从字面理解，Boot是引导的意思，因此SpringBoot帮助开发者快速搭建Spring框架；

SpringBoot帮助开发者快速启动一个Web容器；

SpringBoot继承了原有Spring框架的优秀基因；

SpringBoot简化了使用Spring的过程。

Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，或者采用传统的war部署方式。

Spring Boot 主要目标是：

l 为所有 Spring 的开发提供一个从根本上更快的入门体验

l 开箱即用，但通过自己设置参数，即可快速摆脱这种方式。

l 提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等

l 绝对没有代码生成，也无需 XML 配置。

2. Spring Boot 入门

2.1创建工程

SPRING INITIALIZR是spring boot在构建项目时候非常有效, 虽然说Maven以及Spring boot提供的starter使用起来非常简单, 但是由于组件和关联部分众多,有这样一个可视化的配置构建管理工具仍然很不错. 下面我们将会在IntelliJ IDEA中利用SPRING INITIALIZR来创建一个例子程序。

勾选web（为什么要勾选web，后面会有解释）

项目构建完成之后，等待相关jar包的下载，之后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 http://maven.apache.org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>

   <groupId>com.example</groupId>

   <artifactId>demo</artifactId>

   <version>0.0.1-SNAPSHOT</version>

   <packaging>jar</packaging>

   <name>demo</name>

   <description>Demo project for Spring Boot</description>

      <parent>

          <groupId>org.springframework.boot </groupId>

          <artifactId>spring-boot-starter-parent </artifactId>

          <version>1.5.3.RELEASE </version>

          <relativePath/>  <!-- lookup parent from repository -->

      </parent>

  &lt;properties></br>
    &lt;project.build.sourceEncoding>UTF-8&lt;/project.build.sourceEncoding></br>
    &lt;project.reporting.outputEncoding>UTF-8&lt;/project.reporting.outputEncoding></br>
    &lt;java.version>1.7&lt;/java.version></br>
  &lt;/properties></br>
&lt;dependencies></br>  
    &lt;dependency></br>
        &lt;groupId>org.springframework.boot&lt;/groupId></br>
        &lt;artifactId>spring-boot-starter-web&lt;/artifactId></br>
  &lt;/dependency></br>
  &lt;dependency></br>  
        &lt;groupId>org.springframework.boot&lt;/groupId></br>
        &lt;artifactId>spring-boot-starter-test&lt;/artifactId></br>
        &lt;scope>test&lt;/scope></br>
  &lt;/dependency></br>
&lt;/dependencies></br>
&lt;build></br>  
   &lt;plugins></br>  
      &lt;plugin></br>  
         &lt;groupId>org.springframework.boot&lt;/groupId></br>
         &lt;artifactId>spring-boot-maven-plugin&lt;/artifactId></br>
      &lt;/plugin></br>
   &lt;/plugins></br>
&lt;/build></br>

</projec>

此刻我们可以看见，dependency中我们加入的web部分，也就是我们之前勾选的web。

我们会惊奇地发现，我们的工程自动添加了好多好多jar 包，而这些jar 包正式我们做开发时需要导入的jar 包。

因为这些jar 包被我们刚才加入的spring-boot-starter-web，spring-boot-starter-test所引用了，所以添加spring-boot-starter-web,spring-boot-starter-test后会自动把依赖传递过来。

2.2变更JDK版本

<java.version>XXX</java.version>这里可以进行更改。

注意：

虽然JDK1.6或者1.7都可以使用Spring-Boot，但Spring-Boot官方建议使用JDK1.8。要使用JDK1.8，首先必须要配置JDK1.8后，才可以使用上述方法设置。

2.3 引导类

需要创建一个引导类：

这里我们用SPRING INITIALIZR构建，引导类已经被创建完成，我们不需要额外创建了

package com.example.demo;
 import org.springfr amework.boot.SpringApplication;
 import org.springfr amework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
 public class DemoApplication {
 
    public static void main(String[] args) {
       SpringApplication.run(DemoApplication.class, args);
    }
 }

这里多了一个@SpringBootApplication注解，此注解相当于如下注解的整合：

@Configuration：用于定义一个配置类

@EnableAutoConfiguration ：Spring Boot 会自动根据你jar 包的依赖来自动配置

项目。

@ComponentScan：告诉Spring 哪个packages 的用注解标识的类会被spring

自动扫描并且装入bean 容器。

Banner

直接启动，控制台出现以下标识。

. ____ _ __ _ _

/\ / ___'_ __ _ _(_)_ __ __ _

( ( )\___ | '_ | '_| | '_ / _` |

\/ ___)| |_)| | | | | || (_| | ) ) ) )

' |____| .__|_| |_|_| |_\__, | / / / /

=========|_|==============|___/=/_/_/_/

:: Spring Boot :: (v1.5.3.RELEASE)

这个标识是Spring启动标识，如果不想要，可以设置取消

方案一：

public class DemoApplication {
    public static void main(String[] args) {
       //SpringApplication.run(DemoApplication.class, args);
       SpringApplication application = new SpringApplication(DemoApplication.class);
       application.setBannerMode(Banner.Mode.OFF);
       application.run(args);
    }
 }

方案二：

在application.properties文件中配置

spring.main.banner-mode=off

不仅如此，banner的图案也可以自己设置。我们只需要在resources下，建立一个banner.txt

里面可以配置很多，如下：

#设置控制台中输出内容的颜色

${AnsiColor.BRIGHT_RED}：

#这个是MANIFEST.MF文件中的版本号

${application.version}

#这个是上面的的版本号前面加v后上括号

${application.formatted-version}

#这个是springboot的版本号

${spring-boot.version}

#这个是springboot的版本号

${spring-boot.formatted-version}

比如我设置符号和颜色如下：

${} #红色
${}
  &&&&&&&&&&&&&&&
  &   =^_^=     &
  &&&&&&&&&&&&&&&

那么启动成功之后会显示出：

2.4 入门程序

我们不需要配置文件，直接编写Controller类即可

package com.example.demo.controller;
 import org.springfr amework.web.bind.annotation.RequestMapping;
 import org.springfr amework.web.bind.annotation.RestController;
 @RestController
 public class HelloWorldController {
    @RequestMapping("demo")
    public String demo() {
       return "Hello World!";
    }
 }

@RestController注解:其实就是@Controller和@ResponseBody注解加在一起

启动之前编写的引导类即可

在浏览器地址栏输入http://localhost:8080/demo 即可看到运行结果

2.5热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间。

能不能在我修改代码后不重启就能生效呢？可以，由于Spring Boot应用只是普通的Java应用，所以JVM热交换（hot-swapping）也能开箱即用。不过JVM热交换能替换的字节码有限制，想要更彻底的解决方案可以使用Spring Loaded项目或JRebel。 spring-boot-devtools 模块也支持应用快速重启(restart)。

我们只需要在pom.xml加入如下配置即可

<groupId>org.springfr amework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

</dependency>

3. SpringBoot整合

3.1导入数据库表

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (

`id` bigint(20) NOT NULL AUTO_INCREMENT,

`user_name` varchar(100) DEFAULT NULL COMMENT '用户名',

`password` varchar(100) DEFAULT NULL COMMENT '密码',

`name` varchar(100) DEFAULT NULL COMMENT '姓名',

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

INSERT INTO `user` VALUES ('1', 'zhangsan', '123456', '张三');

INSERT INTO `user` VALUES ('2', 'lisi', '123456', '李四');

INSERT INTO `user` VALUES ('3', 'wangwu', '123456', '王五');

INSERT INTO `user` VALUES ('4', 'xiaohan', '123456', '小韩');

INSERT INTO `user` VALUES ('5', 'xiaoliu', '123456', '小刘');

INSERT INTO `user` VALUES ('6', 'xiaoshitou', '123456', '小石头');

3.2 pom文件添加依赖

在pom.xml中进行如下配置

<groupId>org.springfr amework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

<version>1.4.4.RELEASE</version>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

3.3加入Spring-Boot配置文件

在src/main/resources application.properties 配置文件，内容如下：

spring.main.banner-mode=off
 #DB Configuration:
 spring.datasource.driverClassName=com.mysql.jdbc.Driver
 spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot
 spring.datasource.username=root
 spring.datasource.password=root
 
 #JPA Configuration:
 spring.jpa.databa se=MySQL
 spring.jpa.show-sql=true
 spring.jpa.generate-ddl=true
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy

3.4后端实现

3.4.1创建实体类

package com.example.demo.pojo;
 
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import java.io.Serializable;
 
 @Entity
 public class User implements Serializable {
    @Id
    private Long id;
    private String name;
    private String password;
    private String user_name;

//添加get/set 方法

3.4.2创建DAO接口

package com.example.demo.dao;
 import com.example.demo.pojo.User;
 import org.springfr amework.data.jpa.repository.JpaRepository;
 public interface UserDao extends JpaRepository<User, Long> {
 }

3.4.3创建业务逻辑接口

 import com.example.demo.pojo.User;
 import java.util.List;
 
 public interface UserService {
    public List<User> findAll();
 }

3.4.4创建业务逻辑实现类

import com.example.demo.dao.UserDao;
 import com.example.demo.pojo.User;
 import com.example.demo.service.UserService;
 import org.springfr amework.beans.factory.annotation.Autowired;
 import org.springfr amework.stereotype.Service;
 import java.util.List;
 @Service
 public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Override
    public List<User> findAll() {
       System.out.println("我现在从MySQL中查询数据了");
       List<User> list = this.userDao.findAll();
       return list;
    }
 }

3.4.5创建Controller

import com.example.demo.pojo.User;
 import com.example.demo.service.UserService;
 import org.springfr amework.beans.factory.annotation.Autowired;
 import org.springfr amework.web.bind.annotation.RequestMapping;
 import org.springfr amework.web.bind.annotation.RestController;
 import java.util.List;
 @RestController
 @RequestMapping("user")
 public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("list")
    public List<User> findAll() {
       List<User> list = this.userService.findAll();
       return list;
    }
 }

运行引导类Application，打开浏览器输入http://127.0.0.1:8080/user/list

你可以自己设置访问的端口号在application.properties配置文件中配置

server.port=8081
http://127.0.0.1:8081/user/list

3.4.6前端实现

在resources/static下，自己动手写一个前端页面user.html

浏览器地址栏输入：http://127.0.0.1:8080/user.html，效果如下

上述案例没有进行MyBatis的整合，而是继承了JpaRepository

4. 整合MyBatis

以下展示了整合MyBatis的两种方式：

方式一，不需要配置文件，直接在接口上写sql语句

方式二，添加UserMapper.xml文件，在这个配置文件中写sql语句

在pom.xml中加入以下依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
 </dependency>

4.1编写Mapper

和之前的方式一样，只是多了两个注解，查询语句直接写在接口上。

@Mapper：声明Mapper接口

@Select：声明这个接口所需要使用的sql，当然，有查询的注解，肯定就有增删改的注解。

package com.example.demo.dao;
 import com.example.demo.pojo.User;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Select;
 import java.util.List;
 //在Mybatis的3.4.0以上才有 
 @Mapper
 public interface UserMapper {
    @Select("SELECT * FROM user WHERE name LIKE '%${value}%'")
    public List<User> queryUserByName(String name);
 }

4.2编写Service和Controller

service接口：-

public interface UserService {
    public List<User> findAll();
    public List<User> queryUserByName(String name);
 }

ServiceImpl实现类：

public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private UserMapper userMapper;
    @Override
    public List<User> findAll() {
       System.out.println("我现在从MySQL中查询数据了");
       List<User> list = this.userDao.findAll();
       return list;
    }
    public List<User> queryUserByName(String name) {
        List<User>  list = this.userMapper.queryUserByName(name);
       return list;
    }
 }

Controller添加内容：

//通过名字模糊查询
 @RequestMapping("list/{name}")
 public List<User> queryUserByName(@PathVariable String name) {
    List<User> list = this.userService.queryUserByName(name);
    return list;
 }

打开浏览器输入：http://127.0.0.1:8080/user/list/小

以上所有的配置都是使用的默认配置，我们只需要专注java代码的开发即可，不需要加入配置文件了。

以上就是整合MyBatis的方式一。

但并不是所有得场景都是简单的业务，有时候业务复杂，需要我们加入自定义的配置文件；有时候需要载入例如分页助手这样的插件，辅助开发，所以我们也需要了解如何加载这些配置。如下图结构所示，添加以下配置文件

在配置文件中写查询语句

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="com.example.demo.dao.UserMapper">
    <select id="queryAll" resultType="user">
       select * from user
    </select>
 </mapper>

SqlMapConfig.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>
    <plugins>
       <!-- 通用Mapper -->
       <plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">
          
          <property name="IDENTITY" value="MYSQL" />
          
          <property name="mappers" value="com.github.abel533.mapper.Mapper" />
       </plugin>
    </plugins>
 </configuration>

UserMappper接口修改

import com.example.demo.pojo.User;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Select;
 
 import java.util.List;
 //在Mybatis的3.4.0以上才有 
 @Mapper
 public interface UserMapper extends com.github.abel533.mapper.Mapper<User> {
 
    @Select("SELECT * FROM user WHERE name LIKE '%${value}%'")
    public List<User> queryUserByName(String name);
    // 使用UserMapper.xml配置文件
    public List<User> queryAll();
 }

编写Service和Controller

UserServiceImpl添加如下代码：

@Override
 public List<User> queryAll() {
     List<User> list = this.userMapper.queryAll();
     return list;
 }

UserController 添加如下代码：

@RequestMapping("list/query")
 public List<User> queryUserAll() {
    List<User> list = this.userService.queryAll();
    return list;
 }

4.3在application.properties添加配置

 #spring集成Mybatis环境
 #pojo别名扫描包
 mybatis.type-aliases-package=com.example.demo.pojo
 #加载Mybatis核心配置文件
 mybatis.mapper-locations=classpath:mapper/*Mapper.xml
 mybatis.config-location=classpath:mybatis/SqlMapConfig.xml
 #配置连接池，还需要在pom.xml中加入该连接池的依赖
 #spring.datasource.type=com.jolbox.bonecp.BoneCPDataSource

4.4测试

测试使用UserMapper.xml

浏览器地址栏输入：http://127.0.0.1:8080/user/list/query

以上就是整合MyBatis的方式二。

搞定！SpringBoot的入门学习以及MyBatis整合就结束了！

感谢大家的阅读，不足之处，还请多多指正。

查看全文

相关阅读:
访存模型
 Petri网
 Forward secrecy
TensorFlow训练神经网络cost一直为0
解决tensorflow在训练的时候权重是nan问题
 tf.argmax
Keras教程
 z-score
隐马尔可夫(HMM)、前/后向算法、Viterbi算法
 受限玻尔兹曼机基础教程

原文地址：https://www.cnblogs.com/wing7319/p/6972088.html