【Spring Boot】使用Spring Boot实现简单的后端接口--发布模块(一)

最新推荐文章于 2024-05-18 10:22:35 发布
最新推荐文章于 2024-05-18 10:22:35 发布
阅读量1.5k 收藏 8
点赞数
分类专栏： 后端 文章标签： 后端 小程序 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43853746/article/details/121327981
版权

目录


心血来潮，没事的时候想写一个自己的日记小程序(也叫帖子小程序)把，主要会实现前端页面和简单的后端接口：

大概页面如下：
在这里插入图片描述
请添加图片描述
目前前端页面不全，等我写完在补全吧，大概就这个调了，哈哈~

这篇先实现后端接口：新建一个项目，选择Spring Initializr，项目名自定义。
在这里插入图片描述
实现的目录结构：
在这里插入图片描述

建表

CREATE TABLE `tb_post` (
  `post_id` int(10) NOT NULL AUTO_INCREMENT,
  `post_title` varchar(20) NOT NULL,
  `post_content` varchar(200) NOT NULL,
  `post_type` varchar(5) NOT NULL,
  `priority` int(10) NOT NULL,
  `create_time` datetime NOT NULL,
  `last_time` datetime NOT NULL,
  PRIMARY KEY (`post_id`)
) DEFAULT CHARSET=utf8;

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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.liyingxia</groupId>
    <artifactId>post</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>post</name>
    <description>Demo project for Spring Boot</description>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 数据库 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
    </dependencies>

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


</project>

应用启动入口

PostApplication：

package com.liyingxia.post;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PostApplication {

    public static void main(String[] args) {
        SpringApplication.run(PostApplication.class, args);
        System.out.println("启动成功~");
    }

}

配置类

DataSourceConfig：

package com.liyingxia.post.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.beans.PropertyVetoException;

/**
 * @Package: com.liyingxia.post.config
 * @Description: 配置datasource到ioc容器里面
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:42
 */

@Configuration
// 配置mybatis mapper的扫描路径
@MapperScan("com.liyingxia.post.dao")
public class DataSourceConfig {
    @Value("${jdbc.driver}")
    private String jdbcDriver;
    @Value("${jdbc.url}")
    private String jdbcUrl;
    @Value("${jdbc.username}")
    private String jdbcUsername;
    @Value("${jdbc.password}")
    private String jdbcPassword;

    /**
     * 生成与spring-dao.xml对应的bean dataSource
     *
     * @return
     * @throws PropertyVetoException
     */
    @Bean(name = "dataSource")
    public ComboPooledDataSource createDataSource() throws PropertyVetoException {
        // 生成datasource实例
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 跟配置文件一样设置以下信息
        // 驱动
        dataSource.setDriverClass(jdbcDriver);
        // 数据库连接URL
        dataSource.setJdbcUrl(jdbcUrl);
        // 设置用户名
        dataSource.setUser(jdbcUsername);
        // 设置用户密码
        dataSource.setPassword(jdbcPassword);
        // 配置c3p0连接池的私有属性
        // 连接池最大线程数
        dataSource.setMaxPoolSize(30);
        // 连接池最小线程数
        dataSource.setMinPoolSize(10);
        // 关闭连接后不自动commit
        dataSource.setAutoCommitOnClose(false);
        // 连接超时时间
        dataSource.setCheckoutTimeout(10000);
        // 连接失败重试次数
        dataSource.setAcquireRetryAttempts(2);
        return dataSource;
    }
}

SessionFactoryConfig：

package com.liyingxia.post.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;
import java.io.IOException;

/**
 * @Package: com.liyingxia.post.config
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:43
 */

@Configuration
public class SessionFactoryConfig {
    // mybatis-config.xml.xml配置文件的路径
    private static String mybatisConfigFile;

    @Value("${mybatis_config_file}")
    public void setMybatisConfigFile(String mybatisConfigFile) {
        SessionFactoryConfig.mybatisConfigFile = mybatisConfigFile;
    }

    // mybatis mapper文件所在路径
    private static String mapperPath;

    @Value("${mapper_path}")
    public void setMapperPath(String mapperPath) {
        SessionFactoryConfig.mapperPath = mapperPath;
    }

    // 实体类所在的package
    @Value("${type_alias_package}")
    private String typeAliasPackage;

    @Autowired
    private DataSource dataSource;

    /**
     * 创建sqlSessionFactoryBean 实例 并且设置configtion 设置mapper 映射路径 设置datasource数据源
     *
     * @return
     * @throws IOException
     */
    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactoryBean createSqlSessionFactoryBean() throws IOException {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 设置mybatis configuration 扫描路径
        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource(mybatisConfigFile));
        // 添加mapper 扫描路径
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + mapperPath;
        sqlSessionFactoryBean.setMapperLocations(pathMatchingResourcePatternResolver.getResources(packageSearchPath));
        // 设置dataSource
        sqlSessionFactoryBean.setDataSource(dataSource);
        // 设置typeAlias 包扫描路径
        sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasPackage);
        return sqlSessionFactoryBean;
    }
}

TransactionManagermentConfig：

package com.liyingxia.post.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import javax.sql.DataSource;

/**
 * @Package: com.liyingxia.post.config
 * @Description: 对标spring-service里面的transactionManager,继承TransactionManagementConfigurer是因为开启annotation-driven
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:47
 */

@Configuration
/**
 * 使用:
 * 1. 首先使用注解 @EnableTransactionManagement 开启事务支持后
 * 2. 在Service方法上添加注解 @Transactional 即可
 */
@EnableTransactionManagement
public class TransactionManagementConfig implements TransactionManagementConfigurer {

    @Autowired
    // 注入DataSourceConfiguration里边的dataSource,通过createDataSource()获取
    private DataSource dataSource;

    @Override
    /**
     * 关于事务管理，需要返回PlatformTransactionManager的实现
     */
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

controller

PostController：

package com.liyingxia.post.controller;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.liyingxia.post.entity.Post;
import com.liyingxia.post.service.PostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Package: com.liyingxia.post.controller
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:57
 */

@RestController
@RequestMapping("/manager")
public class PostController {

    @Autowired
    private PostService postService;

    /**
     * 获取所有列表信息
     * @return
     */
    @RequestMapping(value = "/list",method = RequestMethod.GET)
    private Map<String,Object> listPost() {
        Map<String,Object> map = new HashMap<String, Object>();
        List<Post> list = new ArrayList<Post>();
        // 获取帖子列表
        list = postService.getPostList();
        map.put("postList",list);
        return map;
    }


    /**
     * 根据id 查询对应的列表
     * @param postId
     * @return
     */
    @RequestMapping(value = "/postId", method = RequestMethod.GET)
    private Map<String,Object> getPostId(Integer postId) {
        Map<String,Object> map = new HashMap<String,Object>();
        // 获取帖子信息
        Post post = postService.getPostById(postId);
        map.put("post",post);
        return map;
    }

    /**
     * 新增帖子
     * @param post
     * @return
     * @throws JsonParseException
     * @throws JsonMappingException
     * @throws IOException
     */
    @RequestMapping(value = "/addPost", method = RequestMethod.POST)
    private Map<String,Object> addPost(@RequestBody Post post) throws JsonParseException,JsonMappingException,IOException {
        Map<String,Object> map = new HashMap<String,Object>();
        // 添加贴子信息
        map.put("success",postService.addPost(post));
        return map;

    }


    /**
     * 修改帖子
     * @param post
     * @return
     * @throws JsonMappingException
     * @throws JsonParseException
     * @throws IOException
     */
    @RequestMapping(value = "/modify", method = RequestMethod.PUT)
    private Map<String,Object> modifyPost(@RequestBody Post post) throws JsonMappingException,JsonParseException,IOException {
        Map<String,Object> map = new HashMap<String,Object>();
        // 修改贴子信息
        map.put("success",postService.modifyPost(post));
        return map;
    }

    /**
     * 删除根据id帖子
     * @param postId
     * @return
     */
    @RequestMapping(value = "/delete", method = RequestMethod.DELETE)
    private Map<String,Object> deletePost(Integer postId) {
        Map<String,Object> map = new HashMap<String,Object>();
        // 删除信息
        map.put("success",postService.deletePost(postId));
        return map;
    }


}

dao

PostDao：

package com.liyingxia.post.dao;

import com.liyingxia.post.entity.Post;

import java.util.List;

/**
 * @Package: com.liyingxia.post.dao
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:52
 */


public interface PostDao {

    /**
     * 列出帖子列表
     * @return
     */
    List<Post> queryPost();

    /**
     * 根据id获取帖子
     * @param postId
     * @return
     */
    Post queryPostById(int postId);

    /**
     * 插入帖子信息
     * @param post
     * @return
     */
    int insertPost(Post post);

    /**
     * 更新帖子信息
     * @param post
     * @return
     */
    int updatePost(Post post);

    /**
     * 根据id 删除帖子信息
     * @param postId
     * @return
     */
    int deletePost(int postId);
}

entity

Post：

package com.liyingxia.post.entity;

import java.util.Date;

/**
 * @Package: com.liyingxia.post.entity
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:53
 */
public class Post {
    // 主键ID
    private Integer postId;
    // 标题
    private String postTitle;
    // 内容
    private String postContent;
    // 类型
    private String postType;
    // 权重，越大越排前显示
    private Integer priority;
    // 创建时间
    private Date createTime;
    // 更新时间
    private Date lastTime;

    public Integer getPostId() {
        return postId;
    }

    public void setPostId(Integer postId) {
        this.postId = postId;
    }

    public String getPostTitle() {
        return postTitle;
    }

    public void setPostTitle(String postTitle) {
        this.postTitle = postTitle;
    }

    public String getPostContent() {
        return postContent;
    }

    public void setPostContent(String postContent) {
        this.postContent = postContent;
    }

    public String getPostType() {
        return postType;
    }

    public void setPostType(String postType) {
        this.postType = postType;
    }

    public Integer getPriority() {
        return priority;
    }

    public void setPriority(Integer priority) {
        this.priority = priority;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getLastTime() {
        return lastTime;
    }

    public void setLastTime(Date lastTime) {
        this.lastTime = lastTime;
    }
}

service

PostService：

package com.liyingxia.post.service;

import com.liyingxia.post.entity.Post;

import java.util.List;

/**
 * @Package: com.liyingxia.post.service
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:55
 */

public interface PostService {

    /**
     * 获取帖子列表
     * @return
     */
    List<Post> getPostList();

    /**
     * 通过id获取帖子信息
     * @param postId
     * @return
     */
    Post getPostById(int postId);

    /**
     * 新增帖子信息
     * @param post
     * @return
     */
    boolean addPost(Post post);

    /**
     * 修改帖子信息
     * @param post
     * @return
     */
    boolean modifyPost(Post post);

    /**
     * 通过id删除帖子信息
     * @param postId
     * @return
     */
    boolean deletePost(int postId);

}

PostServiceImpl：

package com.liyingxia.post.service.impl;

import com.liyingxia.post.dao.PostDao;
import com.liyingxia.post.entity.Post;
import com.liyingxia.post.service.PostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * @Package: com.liyingxia.post.service.impl
 * @Description:
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:55
 */
@Service
public class PostServiceImpl implements PostService {

    @Autowired
    private PostDao postDao;

    @Override
    public List<Post> getPostList() {
        // 返回所有的帖子信息
        return postDao.queryPost();
    }


    @Override
    public Post getPostById(int postId) {
        return postDao.queryPostById(postId);
    }

    @Transactional
    @Override
    public boolean addPost(Post post) {
        // 控制判断,
        if ((post.getPostTitle() != null && !"".equals(post.getPostTitle()))
                && post.getPostContent() != null && !"".equals(post.getPostContent())
                && post.getPriority() != null && !"".equals(post.getPriority())
                && post.getPostType() != null && !"".equals(post.getPostType())
        ) {
            // 设置创建时间
            post.setCreateTime(new Date());
            post .setLastTime(new Date());
            try{
                int effectedNum = postDao.insertPost(post);
                if (effectedNum > 0) {
                    return true;
                } else {
                    throw new RuntimeException("添加失败");
                }
            } catch (Exception e) {
                throw new RuntimeException("添加失败" + e.toString());
            }
        } else {
            throw new RuntimeException("请填写正确的信息");
        }
    }

    @Override
    public boolean modifyPost(Post post) {
        // 控制判断，postId不为空
        if (post.getPostId() !=null && post.getPostId() > 0) {
            //设置修改时间
            post.setLastTime(new Date());
            try{
                int effectedNum = postDao.updatePost(post);
                if (effectedNum > 0) {
                    return true;
                } else {
                    throw new RuntimeException("更新信息失败！");
                }
            }catch (Exception e) {
                throw new RuntimeException("更新信息失败！" + e.toString());
            }
        } else {
            throw new RuntimeException("请填写正确的信息");
        }
    }

    @Transactional
    @Override
    public boolean deletePost(int postId) {
        if (postId > 0) {
            try {
                // 删除帖子信息
                int effectedNum = postDao.deletePost(postId);
                if (effectedNum > 0) {
                    return true;
                } else {
                    throw new RuntimeException("删除信息失败!");
                }
            } catch (Exception e) {
                throw new RuntimeException("删除信息失败:" + e.toString());
            }
        } else {
            throw new RuntimeException("id不能为空！");
        }
    }
}

handler

GlobalExceptionHandler：

package com.liyingxia.post.handler;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * @Package: com.liyingxia.post.handler
 * @Description: 统一异常处理类
 * @Author: liyingxia
 * @CreateDate: 2021/11/15 9:53
 */
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Map<String, Object> exceptionHandler(HttpServletRequest req, Exception e) throws Exception {
        Map<String, Object> modelMap = new HashMap<String, Object>();
        modelMap.put("success", false);
        modelMap.put("errMsg", e.getMessage());
        return modelMap;
    }

}

Mapper

PostMapper：

<?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.liyingxia.post.dao.PostDao">
    <select id="queryPost" resultType="com.liyingxia.post.entity.Post">
		SELECT post_id, post_title,post_content,post_type,priority, create_time, last_time
		FROM tb_post
		ORDER BY priority
		DESC
	</select>
    <select id="queryPostById" resultType="com.liyingxia.post.entity.Post">
		SELECT post_id, post_title,post_content,post_type,priority, create_time, last_time
		FROM tb_post
		WHERE
		post_id=#{postId}
	</select>
    <insert id="insertPost" useGeneratedKeys="true" keyProperty="postId"
            keyColumn="post_id" parameterType="com.liyingxia.post.entity.Post">
		INSERT INTO
		tb_post(post_title,post_content,post_type,priority,create_time,last_time)
		VALUES
		(#{postTitle},#{postContent},#{postType},#{priority},#{createTime},#{lastTime})
	</insert>
    <update id="updatePost" parameterType="com.liyingxia.post.entity.Post">
        update tb_post
        <set>
            <if test="postTitle != null">post_title=#{postTitle},</if>
            <if test="postContent != null">post_content=#{postContent},</if>
            <if test="postType != null">post_type=#{postType},</if>
            <if test="priority != null">priority=#{priority},</if>
            <if test="lastTime != null">last_time=#{lastTime}</if>
        </set>
        where post_id=#{postId}
    </update>
    <delete id="deletePost">
		DELETE FROM
		tb_post
		WHERE
		post_id =
		#{postId}
	</delete>
</mapper>

mapper标签的namespace属性为该映射文件对应Dao接口类。

  • update标签用于更新操作，id属性为对应方法名
    insert 标签用于插入操作，keyColumn和select语句中的表名相对应的实体类的字段对应，keyProperty和insert语句中的values内的参数一致，也就是和insert语句中的表的对应实体类的字段一致，才可以通过反射完成，paramerType属性为传入方法的参数类型，标签体为操作sql，#{x}为传入参数entity的x属性。useGeneratedKeys="true"使用jdbc的getGeneratedKeys获取数据库自增主键值。

  • select标签用于查询操作，id属性对应方法名。

  • delete标签用于删除操作，id属性对应方法名。

application.properties:

server.port=8080
##加入/post前缀
#server.context-path=/post

#DataSource
#数据库驱动
jdbc.driver=com.mysql.jdbc.Driver
#数据库链接
jdbc.url=jdbc:mysql://localhost:3306/mdatabase?useUnicode=true&characterEncoding=utf8&useSSL=false
#数据库用户名
jdbc.username=root2
#数据库密码
jdbc.password=123456

#Mybatis
mybatis_config_file=mybatis-config.xml
mapper_path=/mapper/**.xml
type_alias_package=com.liyingxia.post.entity

mybatis-config.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>
    <!-- 配置全局属性 -->
    <settings>
        <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true" />

        <!-- 使用列标签替换列别名 默认:true -->
        <setting name="useColumnLabel" value="true" />

        <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
</configuration>

postman测试

保证本地有MySQL数据库服务器运行状态下，运行PostApplication应用程序入口，baseUrl:http://localhost:8080/manager/

获取列表：
在这里插入图片描述
新增：
在这里插入图片描述
更新：
在这里插入图片描述
删除：
在这里插入图片描述

Ly_cat
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java开发实战-创建Springboot项目并发布接口
weixin_42551921的博客
07-02 623
java开发实战-创建Springboot项目并发布接口
springboot+CXF发布webservice接口
07-26
自己总结的springboot集成CXF发布webservice接口，包含说明，代码，截图
spring boot-接口发布
xif3681的博客
09-06 1865
一、clone项目   二、安装环境 1.java sdk http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 环境变量设置： (1)新建-&gt;变量名"JAVA_HOME"，变量值"C:\Java\jdk1.8.0_05"（即JDK的安装路径）  (2)编辑-&...
【Spring】SpringBoot动态生成接口
最新发布
九师兄
05-18 508
最近遇到一个需求，需要在程序运行过程中，可以动态新增接口，自定义接口参数名称，基本类型，以及请求方法，请求头等等。通过几天的研究，找到了我需要的解决方案。对于这个需求，我首先要研究的是程序是怎么加载非等等注解下的接口，然后发现加载接口都需要被RequestMappingInfo处理，可以通过该类进行动态接口生成。
Springboot整合webservice发布接口
千里之行，始于足下！
03-03 587
1:在pom.xml文件中添加需要的引用 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web-services</artifactId> </dependency> <dependency> <groupId>org.apache.cxf</
创建简单的springboot项目（后台）
weixin_41624318的博客
07-05 274
创建简单的Springboot+Mybatis+Maven项目 创建maven项目（略） 配置yml server: port: 8081 spring: application: name: cloud-payment-service datasource: type: com.alibaba.druid.pool.DruidDataSource # 当前数据源操作类型 driver-class-name: org.gjt.mm.mysql.D
使用freeMarker模板和Spring boot后端API接口实现查询用户列表的功能。
03-06
在本项目中，我们将利用FreeMarker模板语言和Spring Boot后端API接口来实现一个用户列表的查询功能。下面，我将详细讲解这个过程中的关键知识点。 1. **FreeMarker模板**： FreeMarker是一个Java模板引擎，它能够...
spring-boot-api:spring-boot 通用APP后端api接口 restful api接口 前后分离后端接口
05-01
Spring Boot restful api 形式接口 适用于APP后端接口服务 前后端分离项目提供接口服务 集成jpa（Java持久层API）ORM jpa的curd 原生curd MySQL分页 阿里数据库连接池druid 封装腾讯云CMQ相关接口 redis相关接口API ...
基于Spring Boot和Mybatis-Plus的音乐网站后端设计源码
04-11
本源码提供了一个基于Spring Boot和Mybatis-Plus的音乐网站后端设计。项目包含52个文件，其中包括30个Java源文件、4个属性文件、3个Gitignore文件、3个JAR包、3个命令文件、3个XML文件、3个YAML文件、1个开发环境...
apimonitor-spring-boot-starter:使用aop实现api监控的一个spring boot starter
05-14
基于AOP实现API监控，给需要监控的接口添加 @ApiMonitor注解即可向api_monitor_record表中插入本次请求相关信息 说明 1. 添加依赖 <groupId>org.abigballofmud <artifactId>apimonitor-spring-boot-starter ...
毕业设计-后端开发-教务系统Spring Boot
05-01
整体业务需求对于学生来说非常简单，是一个适合在校学生学完ssm框架之后的初级练手项目。 目录： - java: 后端代码 - resources：资源 - webapp: 前端代码 jsp开发 数据库表：college，course，role，...
SpringBoot接口Http协议开发实战
09-06
SpringBoot接口Http协议开发实战，很简单很详细的入门哦
【项目实践】SpringBoot三招组合拳，手把手教你打出优雅的后端接口
RudeCrab的博客
03-24 2634
SpringBoot参数校验 + 全局异常处理 + 数据统一响应，手把手教你搭建优雅的后端接口体系
SpringBoot写后端接口，看这一篇就够了！
热门推荐
华为云官方博客
10-12 2万+
摘要：本文演示如何构建起一个优秀的后端接口体系，体系构建好了自然就有了规范，同时再构建新的后端接口也会十分轻松。 一个后端接口大致分为四个部分组成：接口地址（url）、接口请求方式（get、post等）、请求数据（request）、响应数据（response）。如何构建这几个部分每个公司要求都不同，没有什么“一定是最好的”标准，但一个优秀的后端接口和一个糟糕的后端接口对比起来差异还是蛮大的，其中最重要的关键点就是看是否规范! 本文就一步一步演示如何构建起一个优秀的后端接口体系，体系构建好了自然就有了规范
Springboot学习教程（八）springboot整合数据层及事物管理
10-16 360
目录 springboot整合数据层 1.springboot整合JdbcTemplate 2.springboot整合Mybatis 3.springboot整合Springjpa 4.事物管理 springboot整合数据层 我们介绍springboot整合JdbcTemplate，mybatis，springjpa三种方式。 演示springboot项目： ...
Java后端-Postman发布后端接口
weixin_43169156的博客
03-29 527
准备工作： POSTMAN Version 8.0.9客户端 一个可用的电子邮箱 导出已有api数据（适用于已有api但未登录Postman） 点击设置 2. 点击data并导出 登录Postman 若无账号自行注册 点击登录，已有登录记录会保存在浏览器中 登录成功后，点击workspace；能看见操作的记录 发布接口 已有api文件使用上面导出的数据再重新导入，点击设置按钮，切换到data页签下，导入json文件 下面实际操作新建项目并补充接口信息并发布 创建项目文件夹集合，并
springboot项目中，如何将一个postmapping接口发布为springcloud微服务接口
curry300的博客
05-05 249
其中，@PostMapping 注解声明要调用的接口路径，@RequestParam 注解声明接口参数。
.NET Core webapi 从零开始在IIS上面发布后端接口
qq_44695769的博客
07-05 2719
不过C#的特点就是，简单，好用，全栈。C#语法糖很舒服，C#能写后端，桌面端，还有Unity关门大弟子支持。对了，我最近研究了一下C#怎么调用python，已经成功了。就是通过启动python脚本，将参数输进去，然后监听python的运行结果打印。.NET core是以后.NET未来的趋势，虽然我感觉Java在web后端的主导地位10年内不会动摇，因为Java占据了先发优势。我推荐用.NET core 6.0版本，虽然都快过过期了。在Program文件中修改代码。这里建议新手选择独立发布。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值