2. 程式人生 > >使用IDEA搭建SpringBoot專案且整合mongoDB和mysql

使用IDEA搭建SpringBoot專案且整合mongoDB和mysql

阿新 • • 發佈：2019-01-03

SpringBoot專案相對SpringMVC專案有搭建迅速，配置更少的優點。建立springboot專案有很多種方式，本文使用idea建立一個整合mongoDB和mysql資料庫的簡單的springboot專案。文章末尾附原始碼地址。

搭建步驟：

主要是以截圖的方式介紹搭建過程。

  • 進入新建專案介面，按照下圖操作

這裡寫圖片描述

這裡寫圖片描述
這裡寫圖片描述
這裡寫圖片描述

經過以上步驟，基本專案框架就會搭建起來。因為專案中需要用到阿里的資料庫連線池和json工具包，所以在pom檔案中手動加入相應的依賴。

  • 完整pom檔案
<?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.zxd</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.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <druid.version>1.0.29</druid.version>
        <fastjson.version>1.2.30</fastjson.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>


    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.RC1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>
  • 資料庫的基本配置
    專案搭建成功之後，會發現在resources目錄下會生成一個”application.properties”檔案。這個檔案是springboot專案的基本配置檔案，可以重新命名為 “application.yml”。本文的配置均在yml檔案下配置，優點是層次結構清晰。
    配置檔案內容如下：
spring:
#資料庫配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring_boot
    username: root
    password: 123456
  # 配置初始化大小、最小、最大
    initialSize: 5
    minIdle: 5
    maxActive: 20
  # 配置獲取連線等待超時的時間
    maxWait: 60000
  # 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連線，單位是毫秒
    timeBetweenEvictionRunsMillis: 60000
  # 配置一個連線在池中最小生存的時間，單位是毫秒
    minEvictableIdleTimeMillis: 30000
    validationQuery: SELECT 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
   # 開啟PSCache，並且指定每個連線上PSCache的大小。如果用Oracle，則把poolPreparedStatements配置為true，mysql可以配置為false。分庫分表較多的資料庫，建議配置為false。
    poolPreparedStatements: false
    maxPoolPreparedStatementPerConnectionSize: 20
  # 配置監控統計攔截的filters
    filters: stat
#jpa配置
  jpa:
    database: mysql
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update
#mongo配置
  data:
    mongodb:
      database: spring_boot
      uri: mongodb://127.0.0.1:27017

經過以上配置。就可以啟動專案了。
控制檯打印出

2017-04-18 17:56:23.647  INFO 14748 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-04-18 17:56:23.656  INFO 14748 --- [           main] com.zxd.DemoApplication                  : Started DemoApplication in 13.982 seconds (JVM running for 15.253)

類似語句，就說明啟動成功！
可以輸出一個簡單的語句，驗證專案是否搭建成功！

package com.zxd.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zxd
 * @create 2017-03-29 11:02
 **/
@RestController
public class Hello {

    @GetMapping("/")
    public String sayHello(){
        return "hello spring boot";
    }
}

資料操作

在上面的配置中，已經配置好了資料庫連線，並且啟動成功。接下來就要對資料進行增刪改查。

  • mysql資料庫操作
    通過spring-data-jpa進行增刪改查操作。

1.新建user類

package com.zxd.bean;

import com.alibaba.fastjson.JSON;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 * @author zxd
 * @create 2017-03-31 14:41
 **/
@Entity
@DynamicUpdate
@DynamicInsert
public class User {

    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid.hex")
    @Column(name = "id", nullable = false, length = 32, unique = true)
    private String id;

    private int age;

    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this);
    }
}

2.新建Repository

package com.zxd.repository;

import com.zxd.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 15:17
 **/
@Repository
public interface UserRepository extends JpaRepository<User,String> {
    @Modifying
    @Query(value = "update User u set u.age = ?1 where u.id = ?2")
    int modifyAgeById(int age,String id);
}

直接繼承JpaRepository就可以，泛型中的User就是User實體類，String是User的主鍵型別。modifyAgeById方法是自定義的修改方法。裡面自帶的有很多基本的增刪改查方法，在接下來的service中可以看到。
3. 新建serivice和controller

package com.zxd.service;

import com.zxd.bean.User;
import com.zxd.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 17:03
 **/
@Transactional
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User findOne(String id) {
        return userRepository.findOne(id);
    }

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public int modifyAgeById(int age, String id) {
        return userRepository.modifyAgeById(age,id);
    }

    public void delete(String id) {
        userRepository.delete(id);
    }

    public void save(User user) {
        userRepository.save(user);
    }
}

package com.zxd.controller;

import com.alibaba.fastjson.JSON;
import com.zxd.bean.User;
import com.zxd.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 14:52
 **/
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    /**
     * 儲存
     * @param user
     * @return
     */
    @PostMapping
    public String saveUser(User user){
        userService.save(user);
        return user.toString();
    }

    /**
     * 按id查詢
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public String findUser(@PathVariable("id") final String id){
        System.out.println(id);
        User user = userService.findOne(id);
        return user.toString();
    }

    /**
     * 查詢所有
     * @return
     */
    @GetMapping()
    public String findUserAll(){
        List<User> userList = userService.findAll();
        return JSON.toJSONString(userList);
    }

    /**
     * 更新年齡
     * @param id
     * @param age
     * @return
     */
    @PutMapping("/{id}")
    public String updateAge(@PathVariable("id") String id,@RequestParam("age") int age){
       return userService.modifyAgeById(age,id)+"";
    }

    /**
     * 刪除
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    public String delete(@PathVariable("id") String id){
        userService.delete(id);
        return "刪除成功！";
    }
}
  • mongoDB資料庫操作
    通過spring-data-jpa和mongoTemplate進行增刪改查操作。
    1.新建Order類
package com.zxd.bean;

import com.alibaba.fastjson.JSON;
import org.springframework.data.mongodb.core.mapping.Document;

import javax.persistence.Id;

/**
 * 訂單
 *
 * @author zxd
 * @create 2017-03-31 16:34
 **/
@Document
public class Order {
    @Id
    private String id;

    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this);
    }
}

2.新建Repository

package com.zxd.repository;

import com.zxd.bean.Order;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 16:36
 **/
@Repository
public interface OrderRepository extends MongoRepository<Order,String> {

}

這個接口裡面沒有寫任何程式碼。基本的增刪改查功能jpa已經實現了，直接在service呼叫就行。一些複雜的功能我們可以寫一個通用的dao類由mongoTemplate實現。
3.建立公共的dao

package com.zxd.dao.impl;

import com.zxd.dao.IPublicDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 18:06
 **/
@Repository
public class PublicDaoImpl<T> implements IPublicDao{
    @Autowired
    private MongoTemplate mongoTemplate;
    @Override
    public void update(Query query, Update update, Class t) {
        mongoTemplate.updateMulti(query,update,t);
    }
}

這裡只貼出實現類的程式碼，介面定義自行補充。裡面也只有一個簡單的修改方法，這裡只是起一個拋磚引玉的作用，可自行擴充套件。
4. 新建service和controller

package com.zxd.service;

import com.zxd.bean.Order;
import com.zxd.dao.IPublicDao;
import com.zxd.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 17:06
 **/
@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private IPublicDao<Order> publicDao;
    public void save(Order order) {
        orderRepository.save(order);
    }

    public Order findOne(String id) {
        return orderRepository.findOne(id);
    }

    public List<Order> findAll() {
        return orderRepository.findAll();
    }

    public int updateNameById(String id, String name) {
        Query query = new Query(Criteria.where("_id").is(id));
        Update update = Update.update("name",name);
        publicDao.update(query,update,Order.class);
        return 1;
    }

    public void deleteById(String id) {
        orderRepository.delete(id);
    }
}

package com.zxd.controller;

import com.alibaba.fastjson.JSON;
import com.zxd.bean.Order;
import com.zxd.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author zxd
 * @create 2017-03-31 16:45
 **/
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 儲存
     * @param order
     * @return
     */
    @PostMapping
    public String saveOrder(Order order){
        orderService.save(order);
        return order.toString();
    }

    /**
     * 按照id查詢
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public String findOrder(@PathVariable("id") String id){
        return orderService.findOne(id).toString();
    }

    /**
     * 查詢全部
     * @return
     */
    @GetMapping
    public String findAll(){
        return JSON.toJSONString(orderService.findAll());
    }

    /**
     * 修改
     * @param id
     * @param name
     * @return
     */
    @PutMapping("/{id}")
    public String updateName(@PathVariable(value = "id") String id,@RequestParam("name") String name){
        return orderService.updateNameById(id,name)+"";
    }

    /**
     * 刪除
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    public String delete(@PathVariable("id") String id){
        orderService.deleteById(id);
        return "刪除成功！";
    }
}

可以用RESTful測試工具進行呼叫測試。這裡不做測試演示。
至此，一個簡單的springboot專案搭建完成！
專案原始碼地址：https://github.com/devzxd/springboot

相關推薦

使用IDEA搭建SpringBoot專案且整合mongoDB和mysql

SpringBoot專案相對SpringMVC專案有搭建迅速，配置更少的優點。建立springboot專案有很多種方式，本文使用idea建立一個整合mongoDB和mysql資料庫的簡單的springboot專案。文章末尾附原始碼地址。 搭建步驟： 主要

Mac下idea從零建立springboot專案以及整合mybatis和mybatis逆向生成工具-springboot(1)

前言 近期從SSM框架轉為springboot開發restful風格的介面。網路上的資源質量良莠不齊，看了很多部落格，有很多專案名字、專案程式碼、專案id等等等的東西統統一模一樣但是按著來卻是執行不通，我就奇了怪了，你們都是統一思考的麼？ 2018-11-2

Idea 搭建SpringBoot專案

之前一直使用的是springMVC，最近公司開始把springMVC向SpringBoot開始轉換，藉此機會開始好好學習SpringBoot。簡單搭建SpringBoot專案，如有不對，還請大家指出。 1：File--》New--》Project。  2：選擇Spri

使用Idea搭建SpringBoot入門專案

由於工作需要，開始學習springboot。想通過部落格記錄下來學習中的點滴。 第一次寫部落格，如有紕漏錯誤，歡迎各位大佬批評指正，感謝。   1.開啟idea，新建一個專案   2.選擇Spring Initializer，點選next （注

2018 - IDEA 中 搭建 SpringBoot 專案（一）

一、選擇 JDK 二、選擇專案依賴 三、專案結構 四、啟動 一、選擇 JDK    注：這裡可以選擇用war包，即以後將war包複製到Tomcat下解壓部署即可。 二、選擇專案依賴 我們這邊選擇：Web、Freemarker、MySQ

使用IDEA搭建SpringBoot + MyBatis + Oracle專案

  使用Idea搭建SpringBoot + MyBatis + Oracle專案 SpringBoot版本：1.5.9             

SpringBoot入門筆記（二）IDEA下springboot專案spring+mybatis+sqlserver+log4j+簡單登入驗證攔截器的框架搭建

IDEA下springboot專案spring+mybatis+sqlserver+log4j+簡單登入驗證攔截器的框架搭建 先貼一個專案的目錄結構 Attention：templates.html5是templates目錄下新建了一個html5目錄 1.專案建立 這個簡單，選

1.IDEA快速搭建SpringBoot專案

（1）IDEA快速搭建         如果是剛剛安裝好的IDEA，雙擊開啟之後點選create new project 左側欄選中Spring Initializr ，選擇你安裝好的的jdk1.8，點選next。         如果你是已經建立過專案，在專案裡頭，請選

SpringBoot框架搭建系列(二)：整合pagehelper和mybatis-generator

本次我們整合mybatis的分頁外掛pagehelper，以及mapper自動生成的外掛mybatis-generator 先整合mybatis-generator 1、在pom中引入 <plugin> <groupId

使用idea搭建springboot+Mybatis的web專案

1.點選file選擇new中的project進入下面頁面，選中下圖所示選項 2.點選nex進入下面頁面,Group是你專案組織唯一的識別符號，實際對應JAVA的包的結構，是main目錄裡java的目錄結構，Artifact是專案的唯一的識別符號。 3.點選nex進入下面頁

IDEA 中 搭建 SpringBoot 專案（一）

四、啟動 一、選擇 JDK    注：這裡可以選擇用war包，即以後將war包複製到Tomcat下解壓部署即可。 二、選擇專案依賴 我們這邊選擇：Web、Freemarker、MySQL、JDBC  接下來填寫專案名及專案原始碼儲存路徑，如下：

使用idea搭建SpringBoot+Spring jpa專案（實現獲取資料庫資料顯示在頁面中）

搭建SpringBoot準備 javaweb基礎 idea使用基礎 maven使用基礎 開始搭建SpringBoot專案 建立springboot 設定Group、Artifact、Packaging 選擇web及SpringBoot版本 配置app

阿里雲容器映象服務和容器服務搭建springboot專案容器

前言 1、開通阿里雲容器映象服務 1.1、建立名稱空間 1.2、建立映象倉庫(這裡不需要執行，因為我使用程式碼登入的時候就會自動建立) 建立的倉庫名稱（不需要建立，在下面上傳程式碼的時候，我們根據sh命令中的資訊會進行建立，當然我

idea來搭建Springboot專案

作為一個剛入道的小猿，成長的最快步伐，就是不斷的學習，總結，再學習，再總結。寫下部落格，記錄下自己的成長。 接下來就是我第一次用idea來搭建Springboot專案了。 第一步新建project，選擇Spring Initializr 點選next後進入第二步 在

使用IDEA快速搭建SpringBoot專案

最近在學習SpringBoot做了一些簡單的總結：1.獨立執行Spring專案：SpringBoot集成了Tomcat可以直接打成jar包在Linux伺服器上直接執行，執行一個SpringBoot專案只需要通過java -jar xxx.jar &來執行2.提供Sta

idea基於maven搭建springBoot專案並實現介面呼叫

本來這篇部落格早就應該寫了但是最近找工作有些忙就落下了 今天閒來無事就來補上了,SpringBoot就是將SpringMVC替換成SpringBoot依舊是SSM框架 建立依舊由idea+maven來進行 好了接下來我們首先new一個新的project 然後直接next 依照我的習慣

Idea對SpringBoot專案和web專案打包war或者jar流程

修改pom.xml檔案，其中打包流程分為jar或者war兩種形式： <groupId>com.ardo</groupId> <artifactId>springboot_server</artifactId> <vers

使用idea搭建springboot

參照https://blog.csdn.net/u013248535/article/details/55100979/  1.首先利用idea建立一個空的maven專案     空的maven專案結構如圖  2.在pom.xml檔案中

使用Intellij IDEA在maven專案中整合mybatis-generator外掛，自動生成程式碼

1.在dependencies下新增： <dependency> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-core</artif

IDEA在springboot專案下，出現無法找到對應的頁面檔案問題

springboot專案在idea容易出現找不到頁面檔案和tomcat報錯的問題。故對這兩個問題記錄一下。 在POM檔案下，加入如下設定： <!-- 使用IDEA開發工具時，需要加上該resources配置，解決webapp/資源目錄無效的問題 --> <resou