mongodb初成长,spring整合mongodb

最新推荐文章于 2024-05-03 11:47:20 发布
最新推荐文章于 2024-05-03 11:47:20 发布
阅读量551 收藏
点赞数 1
分类专栏： spring maven mongodb 文章标签： spring mongodb 整合 maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quiet_coding/article/details/60574125
版权
spring 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
maven
2 篇文章 0 订阅
订阅专栏
mongodb
1 篇文章 0 订阅
订阅专栏

pom.xml

  <properties>
    <org.springframework.version>4.3.6.RELEASE</org.springframework.version>
  </properties>

<dependencies>
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${org.springframework.version}</version>
    </dependency> 
    <dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
	<dependency>
	    <groupId>org.slf4j</groupId>
	    <artifactId>slf4j-log4j12</artifactId>
	    <version>1.7.23</version>
	</dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-mongodb</artifactId>
        <version>1.10.0.RELEASE</version>
    </dependency>
	<dependency>
	    <groupId>commons-fileupload</groupId>
	    <artifactId>commons-fileupload</artifactId>
	    <version>1.3</version>
	</dependency>
	<dependency>
		<groupId>commons-lang</groupId>
		<artifactId>commons-lang</artifactId>
		<version>2.6</version>
	</dependency>
	<dependency>
		<groupId>com.fasterxml.jackson.core</groupId>
		<artifactId>jackson-core</artifactId>
		<version>2.8.6</version>
	</dependency>
	<dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.8.6</version>
	</dependency>
		
    
    
    <dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-test</artifactId>
	    <version>${org.springframework.version}</version>
	    <scope>test</scope>
	</dependency>
	<dependency>
	    <groupId>junit</groupId>
	    <artifactId>junit</artifactId>
	    <version>4.12</version>
	    <scope>test</scope>
	</dependency>
</dependencies>

applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/data/mongo 
						http://www.springframework.org/schema/data/mongo/spring-mongo.xsd 
						http://www.springframework.org/schema/aop 
						http://www.springframework.org/schema/aop/spring-aop.xsd
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd
						http://www.springframework.org/schema/util
						http://www.springframework.org/schema/util/spring-util.xsd"
	default-autowire="byName">
	
	<!-- 除了具有<context:annotation-config />的功能之外，还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。排除@Controller组件，该组件由SpringMVC配置文件扫描 -->
	<context:component-scan base-package="com.hd.mamainst.app.service,com.hd.mamainst.app.dao,com.hd.mamainst.basedao">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	
	<context:property-placeholder location="classpath*:mongodb.properties"  />
	
	
	<!-- mongo客户端连接 -->
	<mongo:mongo-client id="mongoClient" credentials="${mongo.user}:${mongo.pwd}@${mongo.dbname}" host="${mongo.host}" port="${mongo.port}">
        <mongo:client-options
                connections-per-host="${mongo.connectionsPerHost}"
                min-connections-per-host="${mongo.minConnectionsPerHost}"
                threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
                connect-timeout="${mongo.connectTimeout}"
                max-wait-time="${mongo.maxWaitTime}"
                socket-keep-alive="${mongo.socketKeepAlive}"
                socket-timeout="${mongo.socketTimeout}"
                max-connection-idle-time="${mongo.maxConnectionIdleTime}"
                max-connection-life-time="${mongo.maxConnectionLifeTime}"
        />
    </mongo:mongo-client>
    
    <!-- mongo工厂 -->
    <mongo:db-factory id="mongoDbFactory" mongo-ref="mongoClient" dbname="${mongo.dbname}" />
    
    <!-- mongo操作模板,注入了前面的mongo工厂和自定义mongo转换器 -->
    <mongo:template id="mongoTemplate" db-factory-ref="mongoDbFactory"  write-concern="NORMAL"/>
</beans>

mongodb.properties 

#正式环境
mongo.host=127.0.0.1
mongo.user=mongouser
mongo.pwd=mongpwd
mongo.dbname=test
mongo.port=27017
#每个主机的连接数 
mongo.connectionsPerHost=10
#每个主机的最小连接数
mongo.minConnectionsPerHost=5
#线程队列数，它以上面connectionsPerHost值相乘的结果就是线程队列最大值。如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误
mongo.threadsAllowedToBlockForConnectionMultiplier=5
#连接超时的毫秒。0是默认和无限
mongo.connectTimeout=10000
#最大等待连接的线程阻塞时间
mongo.maxWaitTime=120000
#此参数表示socket I/O读写超时时间,推荐为不超时，即 0    Socket.setSoTimeout(int)
mongo.socketTimeout=0
#该标志用于控制socket保持活动的功能，通过防火墙保持连接活着
mongo.socketKeepAlive=false
#最大连接空闲时间
mongo.maxConnectionIdleTime=1500
#最大连接存留时间
mongo.maxConnectionLifeTime=0


#mongo slave
#mongo.heartbeatSocketTimeout=1000
#mongo.heartbeatConnectTimeout=1500
#mongo.minHeartbeatFrequency=5
#mongo.heartbeatFrequency=10

编写测试类进行测试

MongDbTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class MongoDbTest {
	@Resource
    private MongoTemplate mongoTemplate;
	private static List<String> deleteList;

	@Before
	public void beforeTest() {
		deleteList=new ArrayList<>();
	}
	
	@After
	public void afterTest() {
		for (String id : deleteList) {
			mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), "user");
		}
	}
    
    @Test
    public void saveTest() {
    	//准备
    	AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setLabel("测试用户");
		
		//测试
		mongoTemplate.insert(user1);
		
		//记录删除
		deleteList.add(user1.getId());
		
		//验证
        Assert.assertNotNull(user1.getId());
    }
    
    @Test
    public void findTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setAccountmobile("18080147050");
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
		Query query = new Query(Criteria.where("accountmobile").is("18080147050"));
		List<AccountDocument> list = mongoTemplate.find(query, AccountDocument.class);
		
		//验证
        Assert.assertTrue(list!=null&&list.size()>0);
    }
    
    @Test
    public void updateTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setAccountmobile("18888888888");
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
    	Query query = new Query(Criteria.where("_id").is(user1.getId()));
		mongoTemplate.updateFirst(query, new Update().set("accountmobile", "18080147050"), AccountDocument.class);
		
		//验证
        Assert.assertTrue("18080147050".equals(mongoTemplate.findOne(query, AccountDocument.class).getAccountmobile()));
    }
    
    @Test
    public void deleteTest() {
    	//准备
		AccountDocument user1 = new AccountDocument();
		user1.setCreatedate(new Date());
		user1.setIssigneddelete(false);
		user1.setLabel("测试用户");
		mongoTemplate.insert(user1);
		deleteList.add(user1.getId());
    	
		//测试
		Query query = new Query(Criteria.where("_id").is(user1.getId()));
		mongoTemplate.remove(query, AccountDocument.class);
		
		//验证
        Assert.assertTrue(mongoTemplate.findOne(query, AccountDocument.class)==null);
    }
}


baseDaoImpl(接口略): 

/**
 * Dao实现
 * @author 
 *
 * @param <T>
 */
@Repository
public class BaseDaoImpl<T extends BaseDocument> implements  BaseDao<T> {

	@Autowired
    protected MongoTemplate mongoTemplate;

    public T add(T entity) {
    	if(entity.getIssigneddelete()==null){
    		entity.setIssigneddelete(false);
    	}
    	entity.setCreatedate(new Date());
        mongoTemplate.insert(entity);
        return entity;
    }
    public T queryById(String id) {
        return mongoTemplate.findById(id, this.getEntityClass());
    }

    public List<T> queryList() {
        return mongoTemplate.findAll(this.getEntityClass());
    }

    public List<T> queryList(Query query) {
        return mongoTemplate.find(query, this.getEntityClass());
    }

    public T queryFirst(Query query) {
        return mongoTemplate.findOne(query, this.getEntityClass());
    }

    public Page<T> queryPage(Page<T> page, Query query) {
        //如果没有条件 则所有全部
        query=query==null?new Query(Criteria.where("_id").exists(true)):query;
        long count = this.queryCount(query);
        // 总数
        page.setTotalCount((int) count);
        int currentPage = page.getCurrentPage();
        int pageSize = page.getPageSize();
        query.skip((currentPage - 1) * pageSize).limit(pageSize);
        List<T> rows = this.queryList(query);
        page.build(rows);
        return page;
    }

    public long queryCount(Query query) {
        return mongoTemplate.count(query, this.getEntityClass());
    }

    public WriteResult update(Query query, Update update) {
        if (update==null) {
            return null;
        }
        return mongoTemplate.updateMulti(query, update, this.getEntityClass());
    }

    public T updateOne(Query query, Update update) {
        if (update==null) {
            return null;
        }
        return mongoTemplate.findAndModify(query, update, this.getEntityClass());
    }

    public WriteResult update(T entity) {
        Field[] fields = entity.getClass().getSuperclass().getDeclaredFields();
        if (fields == null || fields.length <= 0) {
            return null;
        }
        Field idField = null;
        // 查找ID的field
        for (Field field : fields) {
            if (field.getName() != null
                    && "id".equals(field.getName().toLowerCase())) {
                idField = field;
                break;
            }
        }
        if (idField == null) {
            return null;
        }
        idField.setAccessible(true);
        String id=null;
        try {
            id = (String) idField.get(entity);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        if (id == null || "".equals(id.trim()))
            return null;
        // 根据ID更新
        Query query = new Query(Criteria.where("_id").is(id));
        
        
        fields = entity.getClass().getDeclaredFields();
        Update update = new Update();
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                Object value = field.get(entity);
                if (value != null) {
                    if ("id".equals(field.getName().toLowerCase())){
                        continue;
                    } else {
                        update = update.set(field.getName(), value);
                    }
                }
            } catch (Exception e) {
               continue;
            }
        }
        return mongoTemplate.updateFirst(query, update, getEntityClass());
    }

    public void deleteObjectByLogic(T t) {
    	mongoTemplate.updateMulti(new Query(Criteria.where("_id").is(t.getId())), Update.update("issigneddelete", true).set("deletedate", new Date()), this.getEntityClass());
    }
    
    public void deleteByLogic(Query query) {
    	mongoTemplate.updateMulti(query, Update.update("issigneddelete", true).set("deletedate", new Date()), this.getEntityClass());
    }
    
    public void deleteObjectByPhysics(T t) {
    	mongoTemplate.remove(new Query(Criteria.where("_id").is(t.getId())), this.getEntityClass());
    }
    
    public void deleteByPhysics(Query query) {
    	mongoTemplate.remove(query, this.getEntityClass());
    }
    /**
     * 获得泛型类
     */
    @SuppressWarnings("unchecked")
	private Class<T> getEntityClass() {
    	Type genType = getClass().getGenericSuperclass();
        if (genType instanceof ParameterizedType) {
        	Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
            if(params!=null&¶ms.length>0){
            	return (Class<T>) params[0];
            }
        }
        return null;
    }
}


Page.java

public class Page<T> implements Serializable {
	private static final long serialVersionUID = 5760097915453738435L;
	public static final int DEFAULT_PAGE_SIZE = 10;
	/**
	 * 每页显示个数
	 */
	private int pageSize;
	/**
	 * 当前页数
	 */
	private int currentPage;
	/**
	 * 总页数
	 */
	private int totalPage;
	/**
	 * 总记录数
	 */
	private int totalCount;
	/**
	 * 结果列表
	 */
	private List<T> rows;
	
	public Page(){
		 this.currentPage = 1;
	     this.pageSize = DEFAULT_PAGE_SIZE;
	}
	public Page(int currentPage,int pageSize){
		this.currentPage=currentPage<=0?1:currentPage;
		this.pageSize=pageSize<=0?1:pageSize;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	public int getCurrentPage() {
		return currentPage;
	}
	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}
	public int getTotalPage() {
		return totalPage;
	}
	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}
	public int getTotalCount() {
		return totalCount;
	}
	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}

	/**
	 * 设置结果 及总页数
	 * @param list
	 */
	 public void build(List<T> rows) {  
	        this.setRows(rows);  
	        int count =  this.getTotalCount();  
	        int divisor = count / this.getPageSize();  
	        int remainder = count % this.getPageSize();  
	        this.setTotalPage(remainder == 0 ? divisor == 0 ? 1 : divisor : divisor + 1);  
	    }
	public List<T> getRows() {
		return rows;
	}
	public void setRows(List<T> rows) {
		this.rows = rows;
	}  
}


AccountDao.java

@Repository
public class AccountDao extends BaseDaoImpl<AccountDocument>{
}


编写测试类进行测试

BaseDaoImplTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class BaseDaoImplTest{
	@Autowired
	private AccountDao userDao;
	@Autowired
	private MongoTemplate mongoTemplate;
	private static List<String> deleteList;

	@Before
	public void beforeTest() {
		deleteList=new ArrayList<>();
	}
	
	@After
	public void afterTest() {
		for (String id : deleteList) {
			mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), "accountDocument");
		}
	}
	
	
	@Test
	public void addTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		user.setAccountpassword("654321");
		
		//测试
		userDao.add(user);
		
		//记录删除
		deleteList.add(user.getId());
				
		//验证
		Assert.assertNotNull(user);
	}

	@Test
	public void findTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		
		//验证
		Assert.assertTrue(user!=null);
	}

	@Test
	public void updateTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		user.setAccountsex("man");
		user.setAccountmobile("18080147050");
		userDao.update(user);
		
		//验证
		user = userDao.queryFirst(new Query(Criteria.where("_id").is(user.getId())));
		Assert.assertTrue(user!= null && "man".equals(user.getAccountsex()));
	}

	@Test
	public void deleteByLogicTest() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		userDao.deleteByLogic(query);
		
		//验证
		user = userDao.queryFirst(query);
		Assert.assertTrue(user.getIssigneddelete()&&user.getDeletedate()!=null);
	}
	
	@Test
	public void deleteByPhysics() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		userDao.deleteByPhysics(query);
		
		//验证
		user = userDao.queryFirst(query);
		Assert.assertTrue(user==null);
	}
	@Test
	public void deleteObjectByLogic() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		userDao.deleteObjectByLogic(user);
		
		//验证
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		Assert.assertTrue(user.getIssigneddelete()&&user.getDeletedate()!=null);
	}
	@Test
	public void deleteObjectByPhysics() {
		//准备
		AccountDocument user = new AccountDocument();
		user.setAccountmobile("18080147050");
		userDao.add(user);
		deleteList.add(user.getId());
		
		//测试
		userDao.deleteObjectByPhysics(user);
		
		//验证
		Query query = new Query(Criteria.where("_id").is(user.getId()));
		user = userDao.queryFirst(query);
		Assert.assertTrue(user==null);
	}
}


lk-eternal
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot配置MongoDB连接池
郭大路路
06-05 2万+
  因为Spring Boot中默认没有提供配置MongoDB连接池的属性，所以需要自己向Spring容器中注入mongoDbFactory 1. 添加依赖 &lt;parent&gt;    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;    &lt;artifactId&gt;spring-boot-starter-...
MongoDb连接池源码追踪
八荒六合唯我独尊
05-21 6761
1. 先来看构建MongoClient使用的参数 MongoClientOptions.Builder optionsBuilder = builder() .applicationName(applicationName) .maxConnectionIdleTime(config.getMaxConnectionIdleTime() == 0 ? MAX_CONNECTION_IDLE_T
MngoDb MongoClientOptions 配置信息及常用配置信息
如果第一次你没有成功，那么称之为1.0版，继续加油。
04-25 7389
Java自学的网站(Java全栈工程师 | 以实例驱动学习 | how2j.cn) MongoClientOptions.Builder addClusterListener(ClusterListener clusterListener)Adds the given cluster listener.//添加给定的集群监听器MongoClientOptions.Builder addComma...
grpc设置连接存活时间及服务端健康检查
空山新雨后，天气晚来秋
07-20 2529
grpc设置连接存活时间及服务端健康检查
解决异常：com.mongodb.MongoSocketReadException: Prematurely reached end of stream
热门推荐
qq_27127145的博客
02-21 2万+
异常描述： 项目使用阿里云的mongo服务一段时间后出现： 原因 mongo没有配置空闲连接时间，而spring boot 默认的空闲连接时间为0。当连接闲置一段时间，由于防火墙或者负载均衡的原因，导致连接被关闭，而客户端并不知道，当客户端继续使用这个关闭的连接进行读写时就会出错。 解决 解决办法就是设置连接闲置时间，当超过这个闲置时间客户端主动关闭连接，下次使用时重新建立连接，这样...
生产问题（二）MongoDb链接失效
m0_69270256的博客
04-19 2万+
线上MongoDB出现了如下图所示的报错，服务端链接失败，查询资料得知Linux会销毁服务器上五分钟未使用的Socket通信链接。
mongodb连接配置实践
做的过程自我总结
09-10 1336
之前百度,google了很多,发现并没有介绍mongodb生产环境如何配置的文章, 当时想参考下都不行, 所以写篇文章,大家可以一块讨论下. 1. MongoClientOptions中的连接池配置: 配置如下: connectionPoolSettings = ConnectionPoolSettings.builder() .minSize(getMinConnectionsPerH
Mongodb的简单介绍和使用
weixin_42739473的博客
03-15 218
1.简介：引用官方文档的一句话 MongoDB is a document database with the scalability and flexibility that you want with the querying and indexing that you need 也就是说mongoDB 是可扩展的、灵活的、支持索引的文档数据库。 2.创建用户 ...
MngoDb MongoClientOptions 常用配置信息
guyueyan577的专栏
03-18 403
MongoClientOptions.Builder addClusterListener(ClusterListener clusterListener) Adds the given cluster listener.//添加给定的集群监听器 MongoClientOptions.Builder addCommandListener(CommandListener commandListene...
Spring XML MongoDB连接配置指定用户名和密码注意事项
weixin_34025051的博客
08-20 1790
背景：MongoDB改成使用用户名和密码连接后 修改遗留工程 使用Spring xml 配置 MongoDB客户端版本 <dependency> <groupId>org.springframework.data</groupId> &lt...
Mongodb连接池JAVA
03-11
Mongodb解决连接池不够的问题，多连接的问题。
JAVA操作MongoDB之spring整合
11-09
使用JAVA操作MongoDB进行简单测试，构建项目工具为Maven，使用的简单案例进行测试，包含增删改查的具体方式以及实现，pom.xml中集成了Spring所需jar包。欢迎下载。
MongoDB整合Spring
07-07
MongoDB整合Spring 源码例子
MongoDB与Spring整合
03-17
MongoDB与Spring整合
详解MongoDB和Spring整合的实例代码
08-30
主要介绍了详解MongoDB和Spring整合的实例代码，Spring提供了MongoTemplate这样一个模板类的实现方法，简化了具体操作。有兴趣的可以了解一下
mongodb整合spring文档
06-07
详细描述spring整合mongodb数据库的配置文件
基于Springboot的家具网站
趙兴晨的博客
05-03 392
本文介绍了一款基于现代Web技术构建的家具网站，旨在通过互联网技术优化家具产品的展示与销售，提高用户的购物体验，同时为家具制造商和零售商提供一个高效的在线销售平台。本研究的主要目的是设计并实现一个高效、易用的家具网站，通过系统化的产品展示流程和智能化的购物功能，提升家具产品的在线销售效率和管理水平。本研究通过设计和实现家具网站，有效地解决了传统家具销售中的展示局限性和购物效率低下的问题，提高了家具产品的在线销售效率和用户的购物体验，并为相关领域的研究和实践提供了有益的参考。
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
最新发布
XING的博客
05-03 449
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
阿里巴巴云原生的博客
04-29 952
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
spring整合mongodb
04-25
好的，您想了解关于Spring和MongoDB整合的相关信息，可以参考以下步骤： 1. 首先您需要在项目中引入相应的Maven依赖，例如： <groupId>org.springframework.data <artifactId>spring-data-mongodb <version>...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值