首页/技術動態

Springboot框架，Springboot項目搭建（前端到數據庫，超詳細，附詳細步驟截圖）

 2023-10-15 阅读 30 评论 0

摘要：下面詳細談談我的第一個springboot項目搭建，希望會給還在摸索的同學一點幫助。 Springboot框架、有興趣的同學請加qq:1718283122 備注csdn —————————————————————————————————————————————— 手動創建springboot項目？項

下面詳細談談我的第一個springboot項目搭建，希望會給還在摸索的同學一點幫助。

Springboot框架、有興趣的同學請加qq:1718283122 備注csdn

——————————————————————————————————————————————

手動創建springboot項目？項目說明：

開發環境：Eclipse 4.42

搭建springboot項目？框架：Springboot

工具：Maven

前端：Html、Thymeleaf

后臺：Hibernate

數據庫：Mysql

?

為什么要搭建Springboot項目？

教科書式的闡述這里就不說了，我就總結為兩個詞語 “簡單、方便”。

為了更加清晰的展示，現在我用一個全新的工作空間來演示springboot項目的搭建過程。

【01】創建一個簡單的maven項目（如果Eclipse不支持Maven項目創建，請先自行安裝Maven，不會問度娘）：

（1.1）右鍵單擊 --> New --> Other

（1.2）輸入Maven，選中Maven Project，點擊Next。

?（1.3）勾選 Use default Workspace location，點擊Next。

（1.4） 選擇 maven-archetype-quickstart，點擊Next。

（1.5）填寫GroupId、ArtifactId、為了統一，你們也照著這個來寫吧?，真實就是填公司性質（.com）和域名（springboot）。填寫好后，Package一欄會自動生成，這也就是項目中的包名，點擊Finish。

（1.6）可以看到，我們的工程已經創建成功了。但貌似現在有一些不完美的地方需要解決。

（1.7）工程創建成功后，可以看到又一個小紅叉，雖然不影響程序運行，但面對有強迫的我們，看著很少難受。選中工程：右鍵單擊-->?Maven --> Update Project

（1.8）什么都不管，直接點擊OK?

（1.9）奈斯！小紅叉已經被我們消滅了！?

【02】加入Springboot框架

（2.1）我們先雙擊打開pom.xml文件，把不要的東西先干掉，最后保留如下所示即可：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. 	<modelVersion>4.0.0</modelVersion>
  4. 	<groupId>com</groupId>
  5. 	<artifactId>springboot</artifactId>
  6. 	<version>0.0.1-SNAPSHOT</version>
  7. 	<packaging>jar</packaging>
  8.     
  9. </project>

（2.2）定義父類：springboot 所有jar包版本，這里為 2.0.5.RELEASE 版本

  1.     <!-- Spingboot相關jar包版本 -->
  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.0.5.RELEASE</version>
  6.     </parent>

（2.3）加入springboot核心包、和web開發必須的包

  1.     <!-- 相關jar包 -->
  2.     <dependencies>
  3.     	<!-- Springboot核心jar包 -->
  4.      	<dependency>
  5.             <groupId>org.springframework.boot</groupId>
  6.             <artifactId>spring-boot-starter</artifactId>
  7.         </dependency>
  8.         <!-- web開發包：包含Tomcat和Springmvc -->
  9.         <dependency>
  10.             <groupId>org.springframework.boot</groupId>
  11.             <artifactId>spring-boot-starter-web</artifactId>
  12.         </dependency>
  13.     </dependencies>

（2.4）可以看到，我們項目測試類現在還有一個大紅叉，是因為我們剛剛吧把初始的Junit包干掉了，現在，我們重新加入Junit包。

（2.5）加入Junit測試包，保存。

  1.         <!-- Junit測試jar包 -->
  2.         <dependency>
  3.             <groupId>junit</groupId>
  4.             <artifactId>junit</artifactId>
  5.             <scope>test</scope>
  6.         </dependency>

（2.6）重新maven update一下，小紅叉就沒有了（這里JRE我手動換成了自己常用的jdk1.8）。

（2.7）我們創建一個App類，用來啟動項目用（創建項目的時候已經有這個類了，現在只需要修改代碼為如下）。

  1. package com.springboot;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. /**
  7.  * 項目啟動類
  8.  */
  9. @SpringBootApplication
  10. public class App {
  11.     
  12.     public static void main(String[] args) {
  13. SpringApplication.run(App.class, args);
  14. }
  15.     
  16. }

里面就一個注解，和一個啟動程序的方法。

（2.8）創建Controller：我們同樣舉例以萬年不變的User為例，取名UserController。

  1. package com.springboot.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6.  
  7. @Controller
  8. public class UserController {
  9.  
  10. 	@RequestMapping("/hello")
  11. 	@ResponseBody
  12. 	public String hello() {
  13. 		return "Hello World !!!";
  14. }
  15. 	
  16. }

（2.9）啟動項目，執行app類中的main函數，如果正常，控制臺出現下面輸出，則項目已經啟動成功了。

（2.10）我們在地址欄目輸入 localhost:8080/hello 進行訪問，如果能看到Hello world字樣，則說明項目springboot已經搭建成功了。

【03】常用配置設置
springboot項目默認配置文件是resources文件夾下的application.yml文件，現在項目沒有這些東西，需要手動進行創建。

（3.1）創建resources文件夾（該文件夾主要存放各種配置資源），如果項目已經有 src/main/resources文件夾，則該步驟略過。如果沒有，請按照鏈接所示創建文件夾：https://www.cnblogs.com/zhangyuanqiang/p/9183908.html（敝人博客園文章）

（3.2）創建 application.yml 文件，選中src/main/java/resources/文件夾-->New-->Other

（3.3）選擇General文件夾下的File，點擊Next

（3.4）輸入application.yml，點擊Finish。

（3.5） 完成創建如圖所示

（3.6）打開application.yml文件進行服務器配置（注意排版保持一致，也注意鍵值對的冒號后有一個空格）

  1. server:
  2.   port: 80
  3.   session-timeout: 30
  4.   tomcat.max-threads: 0
  5.   tomcat.uri-encoding: UTF-8

（3.7）這樣配置后，重啟項目，我們就可以不用輸入端口號了。

【04】修改項目為熱部署（凡有文件修改保存后，自動重啟）

（4.1）打開pom.xml，加入下面依賴，最后重啟一次項目。

  1. <!-- spring-boot熱部署 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5. </dependency>

（4.2）然后修改返回頁面的語句，保存，你會發現項目可以自動重啟了。

（4.3）并且也能訪問成功，說明我們的熱部署也已經配置成功了。

【05】配置 Thymeleaf

現在后臺已經OK，后臺的數據需要顯示到前端，我們這里前端顯示，用springboot常配套的 thymeleaf（相當于c標簽），

這個使用起來很簡單，基本一用就會，會c標簽的更是一點即通。

下面是我對thymeleaf常用使用方式總結，不懂的可以看看：https://blog.csdn.net/sunnyzyq/article/details/86685697

（5.1）在pom.xml中加入thymeleaf

  1. <!-- thymeleaf -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-thymeleaf</artifactId>
  5. </dependency>

（5.2）在resoures文件夾下分別創建templates（主要放html文件）和static（主要放css、js文件）文件夾

（5.3）配置thymeleaf（這樣配置后，再代碼中返回到那個頁面就不用寫過多的前綴和后綴了，達到簡化效果）

  1. spring:
  2. thymeleaf:
  3. prefix: classpath:/templates/
  4. suffix: .html
  5. mode: HTML5
  6. encoding: UTF-8
  7. content-type: text/html
  8. cache: false

（5.4）再UserController.java文件中加入如下代碼，保存。

  1. 	@RequestMapping("/index")
  2. 	public String index(Model model) {
  3. model.addAttribute("name", "jack");
  4. model.addAttribute("age", 20);
  5. model.addAttribute("info", "我是一個愛學習的好青年");
  6. 		return "index";
  7. }

?（5.5）在 templates 文件夾下加入頁面 index.html

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Index</title>
  6. </head>
  7. <body>
  8. 姓名：<input type="text" th:value="${name}"><br/>
  9. 年齡：<input type="text" th:value="${age}"><br/>
  10. 簡介：<input type="text" th:value="${info}"><br/>
  11. </body>
  12. </html>

（5.5）由于配置文件進行了修改，這一次我們需要手動重啟項目，啟動后，輸入 localhost/index 訪問，可以看到數據已經成功顯示到頁面上了。

到此為止，我們前臺、后臺已經打通了，接下來就差最后一步了，把數據存入數據庫。

接下來，我們就采用 hibernate 將數據寫入到數據庫中。

首先到數據庫肯定需要jdbc連接容器和hibernate的相關jar包。

【06】配置數據庫鏈接

（6.1）在pom.xml中加入jdbc鏈接容器相關jar包。

  1. <!-- jdbc鏈接容器 -->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5. </dependency>

（6.2）配置數據庫相關信息（注意datasource的層級是在spring下）：

有數據庫名稱（我這里取名為boot）、數據庫用戶名、數據庫密碼等配置信息（這里你需要填你的數據庫帳號和密碼）

  1. datasource:
  2. url: jdbc:mysql://localhost:3306/boot
  3. driver-class-name: com.mysql.jdbc.Driver
  4. username: root
  5. password: zyq123
  6. initial-size: 10
  7. max-active: 20
  8. max-idle: 8
  9. min-idle: 8

（6.3）在你的mysql中創建對應的數據庫，名稱和你的配置保持一致。

（6.4）加入hibernate相關jar包（springboot中，hibernate的相關jar包已經集成到jpa中了，所以這里只需要引入jpa一個jar依賴即可，再也不用像以前那樣引入一連串的hibernate相關包了）

  1. <!-- jpa（已包含hibernate） -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-data-jpa</artifactId>
  5. </dependency>

（6.5）配置jpa（hibernate）相關信息：

  1.   jpa:
  2.     database: mysql
  3.     show-sql: true
  4.     hibernate:
  5.       ddl-auto: update
  6.       naming:
  7.         physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
  8.     database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

好了，配置現在全部已經搞好了，接下來就是寫dao層了。

在寫Dao層前，先創建我們的測試實體類User

【07】創建相關實體

（7.1）我們創建一個bean文件夾來存放相關實體，首先創建一個BaseBean類，里面主要存放每個實體的公共屬性，比如：id，創建人，創建時間，更新人，更新時間等，這里我們就只寫一個公共屬性ID來演示。

  1. package com.springboot.bean;
  2.  
  3. import javax.persistence.GeneratedValue;
  4. import javax.persistence.GenerationType;
  5. import javax.persistence.Id;
  6. import javax.persistence.MappedSuperclass;
  7.  
  8. @MappedSuperclass
  9. public class BaseBean {
  10.  
  11. 	/**
  12. 	 * 自增長ID
  13. 	 */
  14.     @Id
  15.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  16.     private Long id;
  17.  
  18. }

?

（7.2）創建User實體類

  1. package com.springboot.bean;
  2.  
  3. import javax.persistence.Entity;
  4. import javax.persistence.Table;
  5.  
  6. @Entity
  7. @Table(name = "user")
  8. public class User extends BaseBean {
  9.  
  10. 	private String name;
  11. 	private int age;
  12. 	private String info;
  13.  
  14. 	public String getName() {
  15. 		return name;
  16. }
  17.  
  18. 	public void setName(String name) {
  19. 		this.name = name;
  20. }
  21.  
  22. 	public int getAge() {
  23. 		return age;
  24. }
  25.  
  26. 	public void setAge(int age) {
  27. 		this.age = age;
  28. }
  29.  
  30. 	public String getInfo() {
  31. 		return info;
  32. }
  33.  
  34. 	public void setInfo(String info) {
  35. 		this.info = info;
  36. }
  37.  
  38. }

（7.3）創建Service層接口

  1. package com.springboot.service;
  2.  
  3. import com.springboot.bean.User;
  4.  
  5. public interface UserService {
  6.  
  7. 	/**
  8. 	 * 保存用戶對象
  9. 	 * @param user
  10. 	 */
  11. 	void save(User user);
  12.  
  13. }

（7.4）創建Service實現類（實現先暫時不管，等我們寫了dao層再回來補上）

  1. package com.springboot.service.impl;
  2.  
  3. import org.springframework.stereotype.Service;
  4.  
  5. import com.springboot.bean.User;
  6. import com.springboot.service.UserService;
  7.  
  8. @Service
  9. public class UserServiceImpl implements UserService {
  10.  
  11. 	@Override
  12. 	public void save(User user) {
  13. 		// TODO Auto-generated method stub
  14. 		
  15. }
  16.  
  17. }

（7.5）加入dao層，該層接口都是去繼承JpaRepository接口。

在一個項目中，我們往往會創建一個公共接口來處理到數據庫的請求，比如分頁等，然后每個接口去繼承它即可。

所以我們首先創建這個公共dao層接口：CommonDao

  1. package com.springboot.dao;
  2.  
  3. import org.springframework.data.jpa.repository.JpaRepository;
  4. import org.springframework.stereotype.Repository;
  5.  
  6. import com.springboot.bean.BaseBean;
  7.  
  8. @Repository
  9. public interface CommonDao<T extends BaseBean> extends JpaRepository<T, Long> {
  10.  
  11. }

（7.6）加入UserDao

  1. package com.springboot.dao;
  2.  
  3. import org.springframework.stereotype.Repository;
  4.  
  5. import com.springboot.bean.User;
  6.  
  7. @Repository
  8. public interface UserDao extends CommonDao<User> {
  9.  
  10. }

（7.7）現在回到UserServiceImpl類中，補全之前未完成的代碼

OK，到此為止，所有鏈路都已經打通了，我們現在搞點數據測試一下。

【8】測試

（8.1）修改index.html如下：

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Index</title>
  6. </head>
  7. <body>
  8. <form action="/save" method="post">
  9. 姓名：<input type="text" th:value="${name}" name="name"><br/>
  10. 年齡：<input type="text" th:value="${age}" name="age"><br/>
  11. 簡介：<input type="text" th:value="${info}" name="info"><br/>
  12.     <button>保存</button>
  13. </form>
  14. </body>
  15. </html>

（8.2）再UserController類中增加保存用戶的方法：

  1. 	@Autowired
  2. 	private UserService userService;
  1. 	@RequestMapping("/save")
  2. 	@ResponseBody
  3. 	public String save(User user) {
  4. userService.save(user);
  5. 		return "save success !";
  6. }

（8.3）重啟項目，再次訪問 localhost/index

（8.4）修改頁面數據，點擊保存

（8.5）頁面提示了 save success ！則說明后臺所有鏈路成功打通，數據保存成功！

（8.6）我們進入數據庫，刷新boot數據庫，發現已經創建了的user實體表。

（8.7）打開user表，我們可以發現界面的數據已經成功的幫我們保存到數據庫中了。

至此為止！所有springboot數據從前臺到數據庫已經完全實現了！我相信你也會了！

要是還不會，沒關系！我這里還有源碼給你，記得修改配置文件中數據庫的帳號和密碼哦！

源碼：https://pan.baidu.com/s/1wGEhuPo52F5-w2daAtN_ag

版权声明：本站所有资料均为网友推荐收集整理而来,仅供学习和研究交流使用。

原文链接：https://hbdhgg.com/4/137601.html

上一篇：java中default關鍵字作用，Linux設備樹OF API 中OF的含義
下一篇：策略行為與非策略行為，4.15_strategy_行為型模式：策略模式
标签：Springboot框架手動創建springboot項目搭建springboot項目SpringBoot項目Spring bootSpringboot教程springboot項目分工簡單的springboot項目
Springboot框架

发表评论:

最新文章
阅读排行
猜你喜欢
热门标签

本站为非赢利网站，部分文章来源或改编自互联网及其他公众平台，主要目的在于分享信息，版权归原作者所有，内容仅供读者参考，如有侵权请联系我们删除！

Copyright © 2022 匯編語言學習筆記 Inc. 保留所有权利。

底部版权信息