AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring+SpringMVC+MongoDB案例

2017-03-22 1784
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 MongoDB，独享型 2核8GB
推荐场景：
构建全方位客户视图
简介： ---------------------------------------------------------------------------------------------[版权申明：本文系作者原创，转载请注明出处] 文章出处：http://blog.csdn.net/sdksdk0/article/details/64948728作者：朱培      ID：sdksdk0  
---------------------------------------------------------------------------------------------
[版权申明：本文系作者原创，转载请注明出处] 
文章出处：http://blog.csdn.net/sdksdk0/article/details/64948728
作者：朱培      ID：sdksdk0     
--------------------------------------------------------------------------------------------

     MongoDB是一个NoSql数据库，MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。 MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。其存储结构为BSON。

下面是通过一个Spring+SpringMVC+MongoDB的案例来说明mongodb的基本使用。mongdb的基本结构这里就不再重复说明。从入门到应用。源码地址： https://github.com/sdksdk0/mongodbDemo

一、入门

MongoDB的提供了一个面向文档存储，  将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

首先从入门程序开始。

1、新建maven工程，导入mongodb的驱动包。

         <dependency>
                        <groupId>org.mongodb</groupId>
                        <artifactId>mongodb-driver</artifactId>
                        <version>3.4.2</version>
        </dependency>

2、连接数据库

                MongoClient  mongoClient=new MongoClient("127.0.0.1",27017);
                  //连接到数据库
                  MongoDatabase  mongoDatabase=mongoClient.getDatabase("tf");
                  System.out.println("连接成功");

3、创建集合并获取集合
          
                 mongoDatabase.createCollection("test");
                  //System.out.println("创建集合成功");
                  
                  //获取集合
                  MongoCollection<Document> collection = mongoDatabase.getCollection("test");

4、插入文档
   
      //插入文档
      public static void createDocument(MongoCollection<Document> collection){
            
            Document  document=new Document("title","MongoDB")
                 .append("description", "database")
                 .append("likes", 100)
                 .append("by", "Fly");
            ArrayList<Document> documents = new ArrayList<Document>();
            documents.add(document);
            collection.insertMany(documents);
            System.out.println("文档插入成功");
            
      }


5、查询文档

      //查询文档
      public  static void  findIterable(MongoCollection<Document>  collection){
            FindIterable<Document>  findIterable=collection.find();
            MongoCursor<Document> iterator = findIterable.iterator();
            while(iterator.hasNext()){
                  System.out.println(iterator.next());
            }
      }




6、更新文档

    //更新文档
      public  static void  updateMany(MongoCollection<Document>  collection){
            collection.updateMany(Filters.eq("likes",100),new Document("$set",new Document("likes",200)));
            
            //查询文档
            findIterable(collection);
      }
      
7、删除文档

     //删除
      public  static void deleteMany(MongoCollection<Document>  collection){
            //删除符合条件的第一个文档
            
            collection.deleteOne(Filters.eq("likes",200));
            
            //删除所有符合条件的文档
            collection.deleteMany(Filters.eq("likes",200));
            
            //查询文档
            findIterable(collection);          
      }





二、应用

     这个案例的主要内容是，我们在spring中配置mongodb的数据源，如何可以添加修改删除和条件查询，因为是面向对象的，所以这里可以使用的是HQL语句来操作mongodb数据库。
这里主要用的是用户 userId 、name、age来演示。

1、web.xml配置

<? xml  version = "1.0"  encoding = "UTF-8" ?>
< web-app  xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
       xmlns = "http://java.sun.com/xml/ns/javaee"  xmlns:web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
       xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
       id = "sys"  version = "2.5" >
       < description > mongo </ description >
       < display-name > service Java Deploy V1.0.0 </ display-name >
       < context-param >
             < param-name > webAppRootKey </ param-name >
             < param-value > mongo </ param-value >
       </ context-param >
       <!-- 加载log4j -->
       < context-param >
             < param-name > log4jConfigLocation </ param-name >
             < param-value > /WEB-INF/classes/sysconfig/properties/log4j.properties
             </ param-value >
       </ context-param >
       <!-- 加载xml config -->
       < context-param >
             < param-name > contextConfigLocation </ param-name >
             < param-value > classpath*:syscoreConfig/*/*.xml
            classpath:sysconfig/spring/*.xml
            classpath:sysconfig/springmvc/*.xml
             </ param-value >
       </ context-param >
       <!-- 编码 -->
       < filter >
             < filter-name > encodingFilter </ filter-name >
             < filter-class > org.springframework.web.filter.CharacterEncodingFilter </ filter-class >
             < init-param >
                   < param-name > encoding </ param-name >
                   < param-value > UTF-8 </ param-value >
             </ init-param >
             < init-param >
                   < param-name > forceEncoding </ param-name >
                   < param-value > true </ param-value >
             </ init-param >
       </ filter >
       < filter-mapping >
             < filter-name > encodingFilter </ filter-name >
             < url-pattern > /* </ url-pattern >
       </ filter-mapping >
       <!-- 定义LOG4J监听器 -->
       < listener >
             < listener-class > org.springframework.web.util.Log4jConfigListener </ listener-class >
       </ listener >
       <!-- 监听 自动装配ApplicationContext的配置信息 -->
       < listener >
             < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >
       </ listener >
       <!-- spring mvc -->
       < servlet >
             < servlet-name > springMvc </ servlet-name >
             < servlet-class > org.springframework.web.servlet.DispatcherServlet </ servlet-class >
             < init-param >
                   < param-name > ContextConfigLocation </ param-name >
                   < param-value > classpath:sysconfig/spring-servlet.xml </ param-value >
             </ init-param >
             < load-on-startup > 1 </ load-on-startup >
       </ servlet >
       < servlet-mapping >
             < servlet-name > springMvc </ servlet-name >
             < url-pattern > / </ url-pattern >
       </ servlet-mapping >
       < welcome-file-list >
             < welcome-file > index.jsp </ welcome-file >
       </ welcome-file-list >
</ web-app >




2、spring-mvc.xml配置

扫描注解：

<!-- com.rui.pro.dao.*.impl/**,com.rui.pro.service.*.impl/**,com.rui.pro.controller/** -->
       < context:component-scan  base-package = " **.dao.***,**.service.***,**.controller.**" />
       < bean
             class = "org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" >
             < property  name = "order"  value = "0"  />
       </ bean >
       < bean  id = "messageAdapter"
             class = "org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" >
             < property  name = "messageConverters" >
                   < list >
                         < bean
                               class = "org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"  />
                   </ list >
             </ property >
       </ bean >
       < bean
             class = "org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"  />
       < bean  class = "org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"  />
       < bean  id = "exceptionMessageAdapter"
             class = "org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver" >
             < property  name = "messageConverters" >
                   < list >
                         <!-- Support JSON MappingJacksonHttpMessageConverter -->
                         < bean
                               class = "org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"  />
                   </ list >
             </ property >
       </ bean >





3、db.xml配置
这里配置的是mongodb数据库的属性以及一些包

       < mongo:mongo  id = "mongo"  host = "localhost"  port = "27017" >
             < mongo:options  connections-per-host = "8"
                   threads-allowed-to-block-for-connection-multiplier = "4"
                   connect-timeout = "1000"  max-wait-time = "1500"  auto-connect-retry = "true"
                   socket-keep-alive = "true"  socket-timeout = "1500"  slave-ok = "true"
                   write-number = "1"  write-timeout = "0"  write-fsync = "true"  />
       </ mongo:mongo >
       < mongo:db-factory  id = "mongoDbFactory"  dbname = "tf"
             mongo-ref = "mongo"  />
       < mongo:mapping-converter  base-package = "cn.tf.mongodb.demo.bean"
             id = "mongoConverter"  />
       < bean  id = "mongoTemplate"  class = "org.springframework.data.mongodb.core.MongoTemplate" >
             < constructor-arg  name = "mongoDbFactory"  ref = "mongoDbFactory"  />
             < constructor-arg  name = "mongoConverter"  ref = "mongoConverter"  />
       </ bean >
       < mongo:repositories  base-package = "cn.tf.mongodb.demo.bean"  />
       < bean  id = "userDao"  class = "cn.tf.mongodb.demo.dao.impl.UserDaoImpl" >
             < property  name = "mongoTemplate"  ref = "mongoTemplate"  />
       </ bean >

       <!-- 扫描实现 -->
       < context:annotation-config  />



4、bean类

      private  String  id ;
       private  Integer  userId ;
       private  String  name ;
       private  Integer  age ;

设置其setter/getter方法、构造方法、toString等。


5、Dao层


public  interface  UserDao {
      List<User> get();
      User getOne(Integer id);
      
       public  void  findAndModify(Integer id, Integer age);
       void  insert(User u);
      
       void  removeOne(Integer id);
      
       //修改多条
       void  update(User criteriaUser, User user) ;
      
       // 按条件查询, 分页 <br>
       public  List<User> find(User criteriaUser,  int  skip,  int  limit);
      
       //根据条件查询出来后 再去修改
       public  User findAndModify(User criteriaUser, User updateUser);
       //查询出来后 删除
       public  User findAndRemove(User criteriaUser) ;
       //统计
       public  long  count(User criteriaUser);
       //条件查询
       public  Query getQuery(User criteriaUser);
   }


6、实现类

@Repository
public  class  UserDaoImpl  implements  UserDao {
       private  MongoOperations  mongoTemplate ;
       // @Autowired
       // @Qualifier("mongoTemplate")
       public  void  setMongoTemplate(MongoOperations mongoTemplate) {
             this . mongoTemplate  = mongoTemplate;
      }
       public  List<User> get() {
            List<User> user =  mongoTemplate .findAll(User. class );
             return  user;
      }
       public  User getOne(Integer id) {
            User user =  mongoTemplate .findOne( new  Query(Criteria.where( "userId" )
                        .is(id)), User. class );
             return  user;
      }
       public  void  findAndModify(Integer id, Integer age) {
             /*mongoTemplate.updateFirst(new Query(Criteria.where("userId").is(id)),
                        new Update().inc("age", age), User.class);*/
            
             mongoTemplate .updateFirst( new  Query(Criteria.where( "userId" ).is(id)),
                         new  Update().set( "age" , age), User. class );
      }
       public  void  insert(User u) {
             mongoTemplate .insert(u);
      }
       public  void  removeOne(Integer id) {
            Criteria criteria = Criteria.where( "userId" ).in(id);
             if  (criteria !=  null ) {
                  Query query =  new  Query(criteria);
                   if  (query !=  null
                              &&  mongoTemplate .findOne(query, User. class ) !=  null )
                         mongoTemplate .remove( mongoTemplate .findOne(query, User. class ));
            }
      }
       /**
       * 修改多条  <br>
       *  ------------------------------<br>
       *
       *  @param  criteriaUser
       *  @param  user
       */
       public  void  update(User criteriaUser, User user) {
            Criteria criteria = Criteria.where( "age" ).gt(criteriaUser.getAge());
            ;
            Query query =  new  Query(criteria);
            Update update = Update.update( "name" , user.getName()).set( "age" ,
                        user.getAge());
             mongoTemplate .updateMulti(query, update, User. class );
      }
       /**
       * 按条件查询, 分页  <br>
       *  ------------------------------<br>
       *
       *  @param  criteriaUser
       *  @param  skip
       *  @param  limit
       *  @return
       */
       public  List<User> find(User criteriaUser,  int  skip,  int  limit) {
            Query query = getQuery(criteriaUser);
            query.skip(skip);
            query.limit(limit);
             return  mongoTemplate .find(query, User. class );
      }
       /**
       * 根据条件查询出来后 再去修改  <br>
       *  ------------------------------<br>
       *
       *  @param  criteriaUser
       *            查询条件
       *  @param  updateUser
       *            修改的值对象
       *  @return
       */
       public  User findAndModify(User criteriaUser, User updateUser) {
            Query query = getQuery(criteriaUser);
            Update update = Update.update( "age" , updateUser.getAge()).set( "name" ,
                        updateUser.getName());
             return  mongoTemplate .findAndModify(query, update, User. class );
      }
       /**
       * 查询出来后 删除  <br>
       *  ------------------------------<br>
       *
       *  @param  criteriaUser
       *  @return
       */
       public  User findAndRemove(User criteriaUser) {
            Query query = getQuery(criteriaUser);
             return  mongoTemplate .findAndRemove(query, User. class );
      }
       /**
       * count  <br>
       *  ------------------------------<br>
       *
       *  @param  criteriaUser
       *  @return
       */
       public  long  count(User criteriaUser) {
            Query query = getQuery(criteriaUser);
             return  mongoTemplate .count(query, User. class );
      }
       /**
       * 条件查询
       *
       *  @param  criteriaUser
       *  @return
       */
       public  Query getQuery(User criteriaUser) {
             if  (criteriaUser ==  null ) {
                  criteriaUser =  new  User();
            }
            Query query =  new  Query();
             if  (criteriaUser.getId() !=  null ) {
                  Criteria criteria = Criteria.where( "userId" ).is(criteriaUser.getId());
                  query.addCriteria(criteria);
            }
             if  (criteriaUser.getAge() > 0) {
                  Criteria criteria = Criteria.where( "age" ).gt(criteriaUser.getAge());
                  query.addCriteria(criteria);
            }
             if  (criteriaUser.getName() !=  null ) {
                  Criteria criteria = Criteria.where( "name" ).regex(
                               "^"  + criteriaUser.getName());
                  query.addCriteria(criteria);
            }
             return  query;
      }
}


添加成功之后我们可以使用db.user.find(）命令查看。




7、controller层

@Controller
@RequestMapping ( "user" )
public  class  UserController {
      
       @Autowired
      UserDao  userDao ;
      
       public  void  setUserDao(UserDao userDao) {
             this . userDao  = userDao;
      }
       @RequestMapping ( "test" )
       @ResponseBody
       public  String test(){
             return  "hello" ;
      }
      
       @ResponseBody
       @RequestMapping ( "get" )
       public  List<User> get(HttpServletRequest request,HttpServletResponse response){
            List<User> user= userDao .get();
            System. out .println( this .getClass().getName()+ ":" +user);
             return  user;
      }
}

8、我们可以在浏览器中访问




总之，mongodb是一个非常不错的数据库。通过与spring的整合，可以很方便的使用这个Nosql数据库。







文章标签：
云数据库 MongoDB 版
云数据库 RDS
数据库
Spring
Web App开发
NoSQL
Java
关键词：
Spring Spring mvc
Spring MVC
云数据库 MongoDB 版案例
Spring案例
Spring MVC案例
朱培
目录
相关文章
一枚后端工程狮
|
1月前
|
前端开发 Java 微服务
《深入理解Spring》：Spring、Spring MVC与Spring Boot的深度解析
Spring Framework是Java生态的基石，提供IoC、AOP等核心功能；Spring MVC基于其构建，实现Web层MVC架构；Spring Boot则通过自动配置和内嵌服务器，极大简化了开发与部署。三者层层演进，Spring Boot并非替代，而是对前者的高效封装与增强，适用于微服务与快速开发，而深入理解Spring Framework有助于更好驾驭整体技术栈。
一枚后端工程狮
333 4
Quan_Chen
|
8月前
|
前端开发 Java 测试技术
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@RequestParam
本文介绍了 `@RequestParam` 注解的使用方法及其与 `@PathVariable` 的区别。`@RequestParam` 用于从请求中获取参数值（如 GET 请求的 URL 参数或 POST 请求的表单数据），而 `@PathVariable` 用于从 URL 模板中提取参数。文章通过示例代码详细说明了 `@RequestParam` 的常用属性，如 `required` 和 `defaultValue`，并展示了如何用实体类封装大量表单参数以简化处理流程。最后，结合 Postman 测试工具验证了接口的功能。
Quan_Chen
458 0
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@RequestParam
Quan_Chen
|
8月前
|
JSON 前端开发 Java
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@RequestBody
`@RequestBody` 是 Spring 框架中的注解，用于将 HTTP 请求体中的 JSON 数据自动映射为 Java 对象。例如，前端通过 POST 请求发送包含 `username` 和 `password` 的 JSON 数据，后端可通过带有 `@RequestBody` 注解的方法参数接收并处理。此注解适用于传递复杂对象的场景，简化了数据解析过程。与表单提交不同，它主要用于接收 JSON 格式的实体数据。
Quan_Chen
707 0
Quan_Chen
|
8月前
|
前端开发 Java 微服务
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@PathVariable
`@PathVariable` 是 Spring Boot 中用于从 URL 中提取参数的注解，支持 RESTful 风格接口开发。例如，通过 `@GetMapping(&quot;/user/{id}&quot;)` 可以将 URL 中的 `{id}` 参数自动映射到方法参数中。若参数名不一致，可通过 `@PathVariable(&quot;自定义名&quot;)` 指定绑定关系。此外，还支持多参数占位符，如 `/user/{id}/{name}`，分别映射到方法中的多个参数。运行项目后，访问指定 URL 即可验证参数是否正确接收。
Quan_Chen
453 0
Quan_Chen
|
8月前
|
JSON 前端开发 Java
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@RequestMapping
@RequestMapping 是 Spring MVC 中用于请求地址映射的注解，可作用于类或方法上。类级别定义控制器父路径，方法级别进一步指定处理逻辑。常用属性包括 value（请求地址）、method（请求类型，如 GET/POST 等，默认 GET）和 produces（返回内容类型）。例如：`@RequestMapping(value = &quot;/test&quot;, produces = &quot;application/json; charset=UTF-8&quot;)`。此外，针对不同请求方式还有简化注解，如 @GetMapping、@PostMapping 等。
Quan_Chen
400 0
Quan_Chen
|
8月前
|
JSON 前端开发 Java
微服务——SpringBoot使用归纳——Spring Boot中的MVC支持——@RestController
本文主要介绍 Spring Boot 中 MVC 开发常用的几个注解及其使用方式，包括 `@RestController`、`@RequestMapping`、`@PathVariable`、`@RequestParam` 和 `@RequestBody`。其中重点讲解了 `@RestController` 注解的构成与特点：它是 `@Controller` 和 `@ResponseBody` 的结合体，适用于返回 JSON 数据的场景。文章还指出，在需要模板渲染（如 Thymeleaf）而非前后端分离的情况下，应使用 `@Controller` 而非 `@RestController`
Quan_Chen
315 0
waylau
|
4月前
|
前端开发 Java API
Spring Cloud Gateway Server Web MVC报错“Unsupported transfer encoding: chunked”解决
本文解析了Spring Cloud Gateway中出现“Unsupported transfer encoding: chunked”错误的原因，指出该问题源于Feign依赖的HTTP客户端与服务端的`chunked`传输编码不兼容，并提供了具体的解决方案。通过规范Feign客户端接口的返回类型，可有效避免该异常，提升系统兼容性与稳定性。
waylau
315 0
阿里云云原生
|
9月前
|
人工智能 Cloud Native 安全
DeepSeek + Higress AI 网关/Spring AI Alibaba 案例征集
诚挚地感谢每一位持续关注并使用 Higress 和 Spring AI Alibaba 的朋友，DeepSeek + Higress AI 网关/Spring AI Alibaba 案例征集中。
阿里云云原生
766 107
Unfailed_realme
|
4月前
|
SQL Java 数据库连接
Spring、SpringMVC 与 MyBatis 核心知识点解析
我梳理的这些内容，涵盖了 Spring、SpringMVC 和 MyBatis 的核心知识点。 在 Spring 中，我了解到 IOC 是控制反转，把对象控制权交容器；DI 是依赖注入，有三种实现方式。Bean 有五种作用域，单例 bean 的线程安全问题及自动装配方式也清晰了。事务基于数据库和 AOP，有失效场景和七种传播行为。AOP 是面向切面编程，动态代理有 JDK 和 CGLIB 两种。 SpringMVC 的 11 步执行流程我烂熟于心，还有那些常用注解的用法。 MyBatis 里，#{} 和 ${} 的区别很关键，获取主键、处理字段与属性名不匹配的方法也掌握了。多表查询、动态
Unfailed_realme
150 0
糊涂糊涂123
|
4月前
|
JSON 前端开发 Java
第05课：Spring Boot中的MVC支持
第05课：Spring Boot中的MVC支持
糊涂糊涂123
252 0

热门文章

最新文章

  • 1
    在Ubuntu 22.04上安装MongoDB 6.0的步骤
  • 2
    【SpringBoot（二）】带你认识Yaml配置文件类型、SpringMVC的资源访问路径 和 静态资源配置的原理！
  • 3
    Spring AI Alibaba Admin 开源！以数据为中心的 Agent 开发平台
  • 4
    基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
  • 5
    Spring Boot自动装配
  • 6
    MongoDB BI Connector 实战指南
  • 7
    阿里云数据库MongoDB版正式支持3.4、RocksDB、TerarkDB存储引擎
  • 8
    全新版本MongoDB数据存储席卷物联网
  • 9
    MongoDB 复制集节点增加移除及节点属性配置
  • 10
    执行sh文件 进行MongoDB的业务逻辑导入
  • 1
    构建企业级AI智能体（Spring AI Alibaba + JManus实战）
    1550
  • 2
    京东二面：说下spring中常用的设计模式？ （一个 深入骨髓的答案， 面试官跪下了）
    383
  • 3
    基于Java 17 + Spring Boot 3.2 + Flink 1.18的智慧实验室管理系统核心代码
    320
  • 4
    Spring boot 使用mybatis generator 自动生成代码插件
    939
  • 5
    Java 21 与 Spring Boot 3.2 微服务开发从入门到精通实操指南
    609
  • 6
    Spring Boot 3.x 现代化应用开发实战技巧与最佳实践
    551
  • 7
    Spring AI Alibaba 1.0 GA 正式发布，Java 智能体开发进入新时代
    2088
  • 8
    📨 Spring Boot 3 整合 MQ 构建聊天消息存储系统
    558
  • 9
    Spring Boot 项目实操入门完整教程
    1874
  • 10
    Spring AI Alibaba 1.0 GA 正式发布，Java智能体开发进入新时代
    1589

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第四阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 推荐镜像

    更多
  • mongodb
    • 下一篇
    阿里云对象存储OSS收费标准：500G存储118元1年、