• Spring Boot 项目部署方案，打包 + Shell 脚本部署详解，稳的一批

    本篇和大家分享的是 Spring Boot 打包并结合 Shell 脚本命令部署，重点在分享一个shell 程序启动工具，希望能便利工作；

    • profiles指定不同环境的配置
    • maven-assembly-plugin打发布压缩包
    • 分享shenniu_publish.sh程序启动工具
    • linux上使用shenniu_publish.sh启动程序

    profiles指定不同环境的配置

    通常一套程序分为了很多个部署环境：开发，测试，uat，线上 等，我们要想对这些环境区分配置文件，可以通过两种方式：

    • 通过application.yml中编码指定 profile.active=uat 方式指定
    • 通过mvn中profiles来区分不同环境对应的配置文件夹，人工可以手动在idea勾选生成不同环境的包(推荐)

    这里我们要讲的是第二种，首先在mvn中配置如下内容：

    1. 1 <profiles>
    2.  2 <profile>
    3.  3 <id>node</id>
    4.  4 <properties>
    5.  5 <!--传递给脚本的参数值-->
    6.  6 <activeProfile>node</activeProfile>
    7.  7 <package-name>${scripts_packageName}</package-name>
    8.  8 <boot-main>${scripts_bootMain}</boot-main>
    9.  9 </properties>
    10. 10 <activation>
    11. 11 <activeByDefault>true</activeByDefault>
    12. 12 </activation>
    13. 13 </profile>
    14. 14 <profile>
    15. 15 <id>node1</id>
    16. 16 <properties>
    17. 17 <activeProfile>node1</activeProfile>
    18. 18 <package-name>${scripts_packageName}</package-name>
    19. 19 <boot-main>${scripts_bootMain}</boot-main>
    20. 20 </properties>
    21. 21 </profile>
    22. 22 <profile>
    23. 23 <id>node2</id>
    24. 24 <properties>
    25. 25 <activeProfile>node2</activeProfile>
    26. 26 <package-name>${scripts_packageName}</package-name>
    27. 27 <boot-main>${scripts_bootMain}</boot-main>
    28. 28 </properties>
    29. 29 </profile>
    30. 30 </profiles>

    节点粗解：

    id：用来指定不同环境配置文件所在的目录，如下我这里：

    properties：该节点中的节点是可作为参数传递给其他配置文件，如我这里的package-name节点值就可以在另外的assembly.xml或者shell脚本文件中通过${package-name}获取到，如下：

    activeByDefault：指定默认环境配置文件夹

    maven-assembly-plugin打发布压缩包

    对于springboot程序打包，可以分为jar和war，这里是jar包；有场景是咋们配置文件或者第三方等依赖包不想放到工程jar中，并且把这些文件压缩成一个zip包，方便上传到linux；此时通过maven-assembly-plugin和maven-jar-plugin就可以做到，mvn的配置如：

    1. 1 <plugin>
    2.  2 <groupId>org.apache.maven.plugins</groupId>
    3.  3 <artifactId>maven-jar-plugin</artifactId>
    4.  4 <version>2.6</version>
    5.  5 <configuration>
    6.  6 <archive>
    7.  7 <addMavenDescriptor>false</addMavenDescriptor>
    8.  8 <manifest>
    9.  9 <addClasspath>true</addClasspath>
    10. 10 <classpathPrefix>lib/</classpathPrefix>
    11. 11 <mainClass>${scripts_bootMain}</mainClass>
    12. 12 </manifest>
    13. 13 </archive>
    14. 14 <!--打包排除项-->
    15. 15 <excludes>
    16. 16 <exclude>**/*.yml</exclude>
    17. 17 <exclude>**/*.properties</exclude>
    18. 18 <exclude>**/*.xml</exclude>
    19. 19 <exclude>**/*.sh</exclude>
    20. 20 </excludes>
    21. 21 </configuration>
    22. 22 <executions>
    23. 23 <execution>
    24. 24 <id>make-a-jar</id>
    25. 25 <phase>compile</phase>
    26. 26 <goals>
    27. 27 <goal>jar</goal>
    28. 28 </goals>
    29. 29 </execution>
    30. 30 </executions>
    31. 31 </plugin>
    32. 32
    33. 33 <plugin>
    34. 34 <groupId>org.apache.maven.plugins</groupId>
    35. 35 <artifactId>maven-assembly-plugin</artifactId>
    36. 36 <version>2.4</version>
    37. 37 <!-- The configuration of the plugin -->
    38. 38 <configuration>
    39. 39 <!-- Specifies the configuration file of the assembly plugin -->
    40. 40 <descriptors>
    41. 41 <descriptor>${project.basedir}/src/main/assembly/assembly.xml</descriptor>
    42. 42 </descriptors>
    43. 43 </configuration>
    44. 44 <executions>
    45. 45 <execution>
    46. 46 <id>make-assembly</id>
    47. 47 <phase>package</phase>
    48. 48 <goals>
    49. 49 <goal>single</goal>
    50. 50 </goals>
    51. 51 </execution>
    52. 52 </executions>
    53. 53 </plugin>

    值得注意的地方如下几点：

    • mainClass节点：用来指定启动main函数入口类路径，如这里的：com.sm.EurekaServerApplication
    • excludes节点：排除主jar包中配置等一些列后缀文件，因为我们要包这些配置文件放到主包外面
    • descriptor节点：用来指定assembly插件对应的assembly.xml配置文件

    有了上面mvn配置，我们还需要assembly.xml的配置，这里提取了结合shell脚本发布程序的配置：

    1. <assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.           xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd
    3. http://maven.apache.org/ASSEMBLY/2.0.0 ">
    4.     <id>${activeProfile}</id>
    5.     <!--打包成一个用于发布的zip文件-->
    6.     <formats>
    7.         <format>zip</format>
    8.     </formats>
    9.     <!--true：zip中生成一级目录(此处屏蔽，配合脚本需要profiles后缀)-->
    10.     <includeBaseDirectory>false</includeBaseDirectory>
    11.     <dependencySets>
    12.         <dependencySet>
    13.             <!--打包进zip文件的lib目录-->
    14.             <useProjectArtifact>false</useProjectArtifact>
    15.             <outputDirectory>${package-name}-${activeProfile}/lib</outputDirectory>
    16.             <unpack>false</unpack>
    17.         </dependencySet>
    18.     </dependencySets>
    19.  
    20.     <fileSets>
    21.         <!-- 配置文件打包进zip文件的conf目录 -->
    22.         <fileSet>
    23.             <directory>${project.basedir}/src/main/profiles/${activeProfile}</directory>
    24.             <outputDirectory>${package-name}-${activeProfile}/conf</outputDirectory>
    25.             <includes>
    26.                 <include>**/*</include>
    27.                 <!--<include>*.xml</include>-->
    28.                 <!--<include>*.properties</include>-->
    29.                 <!--<include>*.yml</include>-->
    30.             </includes>
    31.         </fileSet>
    32.  
    33.         <!--启动脚本打包进zip文件-->
    34.         <fileSet>
    35.             <directory>${project.basedir}/src/main/scripts</directory>
    36.             <outputDirectory></outputDirectory>
    37.             <includes>
    38.                 <include>**/*</include>
    39.             </includes>
    40.             <!-- 文件文件权限为777 -->
    41.             <fileMode>777</fileMode>
    42.             <!-- 目录权限为777 -->
    43.             <directoryMode>777</directoryMode>
    44.             <!--脚本中参数变量为pom中的值 关键-->
    45.             <filtered>true</filtered>
    46.         </fileSet>
    47.  
    48.         <!-- 项目编译出来的jar打包进zip文件 -->
    49.         <fileSet>
    50.             <directory>${project.build.directory}</directory>
    51.             <outputDirectory>${package-name}-${activeProfile}/</outputDirectory>
    52.             <includes>
    53.                 <include>*.jar</include>
    54.             </includes>
    55.         </fileSet>
    56.     </fileSets>
    57. </assembly>

    重点节点介绍：

    • formats节点：把配置文件和jar包等压缩成什么文件格式，这里可以有：zip，tar等
    • fileMode节点：指定scripts目录下脚本文件(这里是：shenniu_publish.sh)在linux上文件权限为777
    • filtered节点：脚本中参数变量为pom的profiles中properties的值(该配置，是把mvn中属性值映射生成到sh文件中，如：${package-name})

    完成上面配置后，此时我们可以通过idea上勾选切换不同环境来打zip包，如图：

    分享shenniu_publish.sh程序启动工具

    上面步骤完成了zip格式的发布包，我们再分享下启动程序的shell脚本，该脚本具有的功能如：

    • 解压zip+启动jar包
    • 启动jar包
    • 停止对应jar运行
    • 重启jar程序

    目前该shell中封装了两种启动jar命令的方式：

    • java -cp
    • java -jar

    如图命令格式：

    来看全部的shell代码：

    1. #!/usr/bin/env bash
    2. #可变参数变量
    3. languageType="javac" #支持 java,javac,netcore 发布
    4. #参数值由pom文件传递
    5. baseZipName="${package-name}-${activeProfile}" #压缩包名称 publish-test.zip的publish
    6. packageName="${package-name}" #命令启动包名 xx.jar的xx
    7. mainclass="${boot-main}" #java -cp启动时，指定main入口类;命令：java -cp conf;lib\*.jar;${packageName}.jar ${mainclass}
    8.  
    9. #例子
    10. # baseZipName="publish-test" #压缩包名称 publish-test.zip的publish
    11. # packageName="publish" #命令启动包名 publish.jar的xx
    12.  
    13. #固定变量
    14. basePath=$(cd `dirname $0`/; pwd)
    15. baseZipPath="${basePath}/${baseZipName}.zip"  #压缩包路径
    16. baseDirPath="${basePath}" #解压部署磁盘路径
    17. pid= #进程pid
    18.  
    19. #解压
    20. function shenniu_unzip()
    21. {
    22.     echo "解压---------------------------------------------"
    23.     echo "压缩包路径：${baseZipPath}"
    24.     if [ ! `find ${baseZipPath}` ]
    25.     then
    26.         echo "不存在压缩包：${baseZipPath}"
    27.     else
    28.         echo "解压磁盘路径：${baseDirPath}/${baseZipName}"
    29.         echo "开始解压..."
    30.  
    31.         #解压命令
    32.         unzip -od ${baseDirPath}/${baseZipName} ${baseZipPath}
    33.  
    34.         #设置执行权限
    35.         chmod +x ${baseDirPath}/${baseZipName}/${packageName}
    36.  
    37.         echo "解压完成。"
    38.     fi
    39. }
    40.  
    41. #检测pid
    42. function getPid()
    43. {
    44.     echo "检测状态---------------------------------------------"
    45.     pid=`ps -ef | grep -n ${packageName} | grep -v grep | awk '{print $2}'`
    46.     if [ ${pid} ]
    47.     then
    48.         echo "运行pid：${pid}"
    49.     else
    50.         echo "未运行"
    51.     fi
    52. }
    53.  
    54. #启动程序
    55. function start()
    56. {
    57.     #启动前，先停止之前的
    58.     stop
    59.     if [ ${pid} ]
    60.     then
    61.         echo "停止程序失败，无法启动"
    62.     else
    63.         echo "启动程序---------------------------------------------"
    64.  
    65.         #选择语言类型
    66.         read -p "输入程序类型(java,javac,netcore)，下一步按回车键(默认：${languageType})：" read_languageType
    67.         if [ ${read_languageType} ]
    68.         then
    69.             languageType=${read_languageType}
    70.         fi
    71.         echo "选择程序类型：${languageType}"
    72.  
    73.         #进入运行包目录
    74.         cd ${baseDirPath}/${baseZipName}
    75.  
    76.         #分类启动
    77.         if [ "${languageType}" == "javac" ]
    78.         then
    79.             if [ ${mainclass} ]
    80.             then
    81.                 nohup java -cp conf:lib\*.jar:${packageName}.jar ${mainclass} >${baseDirPath}/${packageName}.out 2>&1 &
    82.                #nohup java -cp conf:lib\*.jar:${packageName}.jar ${mainclass} >/dev/null 2>&1 &
    83.             fi
    84.         elif [ "${languageType}" == "java" ]
    85.         then
    86.             nohup java -jar ${baseDirPath}/${baseZipName}/${packageName}.jar >/dev/null 2>&1 &
    87.             # java -jar ${baseDirPath}/${baseZipName}/${packageName}.jar
    88.         elif [ "${languageType}" == "netcore" ]
    89.         then
    90.             #nohup dotnet run ${baseDirPath}/${baseZipName}/${packageName} >/dev/null 2>&1 &
    91.             nohup ${baseDirPath}/${baseZipName}/${packageName} >/dev/null 2>&1 &
    92.         fi
    93.  
    94.         #查询是否有启动进程
    95.         getPid
    96.         if [ ${pid} ]
    97.         then
    98.             echo "已启动"
    99.             #nohup日志
    100.             tail -n 50 -f ${baseDirPath}/${packageName}.out
    101.         else
    102.             echo "启动失败"
    103.         fi
    104.     fi
    105. }
    106.  
    107. #停止程序
    108. function stop()
    109. {
    110.     getPid
    111.     if [ ${pid} ]
    112.     then
    113.         echo "停止程序---------------------------------------------"
    114.         kill -9 ${pid}
    115.  
    116.         getPid
    117.         if [ ${pid} ]
    118.         then
    119.             #stop
    120.             echo "停止失败"
    121.         else
    122.             echo "停止成功"
    123.         fi
    124.     fi
    125. }
    126.  
    127. #启动时带参数，根据参数执行
    128. if [ ${#} -ge 1 ]
    129. then
    130.     case ${1} in
    131.         "start")
    132.             start
    133.         ;;
    134.         "restart")
    135.             start
    136.         ;;
    137.         "stop")
    138.             stop
    139.         ;;
    140.         "unzip")
    141.             #执行解压
    142.             shenniu_unzip
    143.             #执行启动
    144.             start
    145.         ;;
    146.         *)
    147.             echo "${1}无任何操作"
    148.         ;;
    149.     esac
    150. else
    151.     echo "
    152.     command如下命令：
    153.     unzip：解压并启动
    154.     start：启动
    155.     stop：停止进程
    156.     restart：重启
    158.     示例命令如：./shenniu_publish start
    159.     "
    160. fi

    正如上面小节说的，shell中的参数 package-name，activeProfile，boot-main 都是由mvn中profiles的properties中提供，是可变的参数，脚本代码本身不需要人工去修改，只需要变的是mvn的参数即可；其实在我们生成zip包的时候，shell中的参数就被替换了，可以看zip中shell文件内容如：

    把生成的zip上传到linux上，通过命令解压：

    1 unzip -od eureka-server-0.0.1-node eureka-server-0.0.1-node.zip

    其实shell脚本中包含有解压命令，但是我在打包时放在了zip中，所以只能通过手动解压了，当然可以调整；此时进入加压目录如此：

    注：这里第一次执行./shenniu_publish.sh脚本时候，提示了错误信息；是由于我是在windows上编辑的这个脚本，其空格等和linux上不一样，所以运行会有问题，要解决可以使用vim命令在linux把该文件转成linux格式，如下命令：

    1. 1 vim shenniu_publish.sh
    2. 2 set ff=unix
    3. 3 :wq

    执行完后，再来运行脚本./shenniu_publish.sh，此时有如下提示:

    此刻我们文件是解压状态，因此只需要start命令启动程序即可：

    到这里shenniu_publish.sh脚本使用就完成了，只要脚本没有提示错误，基本都能启动jar服务；其他restart和stop命令也如此执行就行：

    可以去研究下shell代码，希望该脚本能给你带来效率和好的学习思路！
    项目源码资料获取方式：关注小编+转发文章+私信【 666 】免费获取！！！

    Java八股文面试资料获取方式：关注小编+转发文章+私信【 13 】免费获取！！！

    Sprig面试题分享

    一、注解(annotations)列表

    @SpringBootApplication：

    包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。

    @Configuration 等同于spring的XML配置文件；使用Java代码可以检查类型安全。

    @EnableAutoConfiguration 自动配置。

    @ComponentScan 组件扫描，可自动发现和装配一些Bean。

    @Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。

    @RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。

    @Autowired自动导入。

    @PathVariable获取参数。

    @JsonBackReference解决嵌套外链问题。

    @
    RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。

    二、注解(annotations)详解

    @SpringBootApplication：申明让spring boot自动给程序进行必要的配置，这个配置等同于：@Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三个配置。

    1. package com.example.myproject; 
    2. import org.springframework.boot.SpringApplication; 
    3. import org.springframework.boot.autoconfigure.SpringBootApplication;
    4.  
    5. @SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan 
    6. public class Application { 
    7. public static void main(String[] args) { 
    8. SpringApplication.run(Application.class, args); 
    9. } 
    10. }

    @ResponseBody：表示该方法的返回结果直接写入HTTP response body中，一般在异步获取数据时使用，用于构建RESTful的api。在使用@RequestMapping后，返回值通常解析为跳转路径，加上@responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如异步获取json数据，加上@responsebody后，会直接返回json数据。该注解一般会配合@RequestMapping一起使用。示例代码：

    1. @RequestMapping(“/test”) 
    2. @ResponseBody 
    3. public String test(){ 
    4. return”ok”; 
    5. }

    @Controller：用于定义控制器类，在spring 项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），一般这个注解在类中，通常方法需要配合注解@RequestMapping。示例代码：

    1. @Controller 
    2. @RequestMapping(“/demoInfo”) 
    3. publicclass DemoController { 
    4. @Autowired 
    5. private DemoInfoService demoInfoService;
    6.  
    7. @RequestMapping("/hello")
    8. public String hello(Map<String,Object> map){
    9.    System.out.println("DemoController.hello()");
    10.    map.put("hello","from TemplateController.helloHtml");
    11.    //会使用hello.html或者hello.ftl模板进行渲染显示.
    12.    return"/hello";
    13. }
    14. }

    @RestController：用于标注控制层组件(如struts中的action)，@ResponseBody和@Controller的合集。示例代码：

    1. package com.kfit.demo.web;
    2.  
    3. import org.springframework.web.bind.annotation.RequestMapping; 
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6.  
    7. @RestController 
    8. @RequestMapping(“/demoInfo2”) 
    9. publicclass DemoController2 {
    10.  
    11. @RequestMapping("/test")
    12. public String test(){
    13.    return"ok";
    14. }
    15. }

    @RequestMapping：提供路由信息，负责URL到Controller中的具体函数的映射。

    @EnableAutoConfiguration：Spring Boot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库”。

    你可以将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。

    @ComponentScan：表示将该类自动发现扫描组件。个人理解相当于，如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，可以自动收集所有的Spring组件，包括@Configuration类。我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。可以自动收集所有的Spring组件，包括@Configuration类。

    我们经常使用@ComponentScan注解搜索beans，并结合@Autowired注解导入。如果没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。

    @Configuration：相当于传统的xml配置文件，如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。

    @Import：用来导入其他配置类。

    @ImportResource：用来加载xml配置文件。

    @Autowired：自动导入依赖的bean

    @Service：一般用于修饰service层的组件

    @Repository：使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

    @Bean：用@Bean标注方法等价于XML中配置的bean。

    @Value：注入Spring boot application.properties配置的属性的值。示例代码：

    1. @Value(value = “#{message}”) 
    2. private String message;

    @Inject：等价于默认的@Autowired，只是没有required属性；

    @Component：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

    @Bean:相当于XML中的,放在方法的上面，而不是类，意思是产生一个bean,并交给spring管理。

    @AutoWired：自动导入依赖的bean。byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。当加上（required=false）时，就算找不到bean也不报错。

    @Qualifier：当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，具体使用方式如下：

    1. @Autowired 
    2. @Qualifier(value = “demoInfoService”) 
    3. private DemoInfoService demoInfoService;

    @Resource(name=”name”,type=”type”)：没有括号内内容的话，默认byName。与@Autowired干类似的事。

    三、JPA注解

    @Entity：@Table(name=”“)：表明这是一个实体类。一般用于jpa这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table可以省略

    @MappedSuperClass:用在确定是父类的entity上。父类的属性子类可以继承。

    @NoRepositoryBean:一般用作父类的repository，有这个注解，spring不会去实例化该repository。

    @Column：如果字段名与列名相同，则可以省略。

    @Id：表示该属性为主键。

    @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”)：表示主键生成策略是sequence（可以为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。

    @SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1)：name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称可以一致。

    @Transient：表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic。@Basic(fetch=FetchType.LAZY)：标记可以指定实体属性的加载方式

    @JsonIgnore：作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。

    @JoinColumn（name=”loginId”）:一对一：本表中指向另一个表的外键。一对多：另一个表指向本表的外键。

    @OneToOne、@OneToMany、@ManyToOne：对应hibernate配置文件中的一对一，一对多，多对一。

    四、springMVC相关注解

    @RequestMapping：@RequestMapping(“/path”)表示该控制器处理所有“/path”的UR L请求。RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。

    用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

    该注解有六个属性：

    1. params:指定request中必须包含某些参数值是，才让该方法处理。
    2. headers:指定request中必须包含某些指定的header值，才能让该方法处理请求。
    3. value:指定请求的实际地址，指定的地址可以是URI Template 模式
    4. method:指定请求的method类型， GET、POST、PUT、DELETE等
    5. consumes:指定处理请求的提交内容类型（Content-Type），如application/json,text/html;
    6. produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回

    @RequestParam：用在方法的参数前面。

    1. @RequestParam 
    2. String a =request.getParameter(“a”)。

    @PathVariable:路径变量。如

    1. RequestMapping(“user/get/mac/{macAddress}”) 
    2. public String getByMacAddress(@PathVariable String macAddress){ 
    3. //do something; 
    4. }

    参数与大括号里的名字一样要相同。

    五、全局异常处理

    @ControllerAdvice：包含@Component。可以被扫描到。统一处理异常。

    @ExceptionHandler（Exception.class）：用在方法上面表示遇到这个异常就执行以下方法。

                                                                    👇🏻 添加 博主 获取完整版源码资料👇🏻   

  • 相关阅读:
    java毕业设计智慧防疫上报系统服务端Mybatis+系统+数据库+调试部署
    Spring-Java
    数字IC设计经验整理（二）
    ESP8266-Arduino网络编程实例-接入WiFi网络
    计算机网络——随机接入
    C++【STL】【string类的模拟实现】【string类的深浅拷贝】
    鸿蒙应用开发-初见：ArkUI
    全球各个国家名的英文
    Leetcode 1796. 字符串中第二大的数字
    vue做的一个一点就转的转盘（音乐磁盘），点击停止时会在几秒内缓慢停止，再次点击按钮可以再次旋转，
  • 原文地址：https://blog.csdn.net/m0_61926454/article/details/125334454