我要评论一、java整合mongodb
1.java连接mongodb
在new project那里创建一个普通的maven项目mongodbexample。
引入java整合mongodb的依赖
<!-- 引入java整合mongodb的依赖 -->
<dependency>
<groupid>org.mongodb</groupid>
<artifactid>mongo-java-driver</artifactid>
<version>3.12.11</version>
</dependency>
在java根目录的com.zzx的包下，创建类mongodbexample，添加如下代码
public class mongodbexample {
public static void main(string[] args) {
//获取mongodb连接地址
string connectionstring = system.getproperty("mongodb.uri");
try {
mongoclient mongoclient = mongoclients.create(connectionstring);
arraylist<document> databases = mongoclient.listdatabases().into(new arraylist<>());
databases.foreach(db-> system.out.println(db.tojson()));
}catch (exception e)
{
e.printstacktrace();
}
}
}
即连接到mongodb并输出所有数据库
点击alt+shift+f10，选择edit configuration，然后选择modify options->选择add vm options，在框内输入该参数：
-dmongodb.uri="mongodb://192.168.126.16:27017/?maxpoolsize=2&w=majority"
最后点击run即可。
在java根目录的com.zzx的包下，创建类mongodbexample2，添加如下代码：
public class mongodbexample2 {
public static void main(string[] args) {
properties properties = new properties();
try {
//使用classloader加载properties文件生成对应的输入流
inputstream resourceasstream = mongodbexample2.class.getclassloader().getresourceasstream("config.properties");
//使用properties对象加载输入流
properties.load(resourceasstream);
//获取属性对应的value值
string connectionstring = properties.getproperty("mongodb.uri");
system.out.println(connectionstring);
//获取mongoclient对象
mongoclient mongoclient = mongoclients.create(connectionstring);
arraylist<document> databases = mongoclient.listdatabases().into(new arraylist<>());
databases.foreach(db-> system.out.println(db.tojson()));
} catch (ioexception e) {
throw new runtimeexception(e);
}
}
}
在resources目录下，创建配置文件config.properties，添加如下配置：
mongodb.uri=mongodb://192.168.126.16:27017/?maxpoolsize=2&w=majority
2.java操作mongodb
新建一个类，mongodbcrud，将获取mongoclient对象的部分封装到方法中
public class mongodbcrud {
public static void main(string[] args) {
try {
mongoclient mongoclient = getmongoclient("config.properties");
} catch (ioexception e) {
throw new runtimeexception(e);
}finally {
mongoclient.close();
}
}
/**
* 获取mongoclient对象
* @param propertyfilename
* @return
* @throws ioexception
*/
private static mongoclient getmongoclient(string propertyfilename) throws ioexception {
properties properties = new properties();
//使用classloader加载properties文件生成对应的输入流
inputstream resourceasstream = mongodbcrud.class.getclassloader().getresourceasstream(propertyfilename);
//使用properties对象加载输入流
properties.load(resourceasstream);
//获取属性对应的value值
string connectionstring = properties.getproperty("mongodb.uri");
//获取mongoclient对象
mongoclient mongoclient = mongoclients.create(connectionstring);
return mongoclient;
}
}
创建集合，即在获取mongoclient对象后面添加如下两行
//获取database数据库对象mydb
mongodatabase mydb = mongoclient.getdatabase("mydb");
//创建集合
mydb.createcollection("examplecollection");
添加文档，代码如下：
//获取集合对象
mongocollection<document> collection = mydb.getcollection("examplecollection");
//创建文档对象
document document = document.parse("{name: 'zhangsan',city: 'beijing',birthday: new isodate('2000-04-02'),expectsalary: 18000}");
//插入文档
collection.insertone(document);
查询文档
//创建文档对象
document document = document.parse("{name: 'zhangtao',city: 'beijing',birthday: new isodate('2000-04-02'),expectsalary: 13000}");
document document2 = document.parse("{name: 'lisi',city: 'beijing',birthday: new isodate('2000-04-02'),expectsalary: 12000}");
document document3 = document.parse("{name: 'wangwu',city: 'beijing',birthday: new isodate('2000-04-02'),expectsalary: 16000}");
//插入文档
collection.insertone(document);
collection.insertone(document2);
collection.insertone(document3);
//按照expectsalary倒排
document expectsalary = new document();
expectsalary.append("expectsalary", -1);
finditerable<document> finditerable = collection.find().sort(expectsalary);
for (document doc:finditerable) {
system.out.println(doc);
}
查询指定条件的文档
//按指定的属性值查询
finditerable<document> documents = collection.find(new document("expectsalary", new document("$eq", 16000)));
for (document doc:documents) {
system.out.println(doc);
}
查询过滤文档
//过滤查询 gt大于，gte大于等于
finditerable<document> filtersexpectsalary = collection.find(filters.gte("expectsalary", 13000)).sort(expectsalary);
for (document doc:filtersexpectsalary) {
system.out.println(doc);
}
二、springboot整合mongodb
1.搭建mongodb的web项目
创建一个springboot项目mongodb-springboot，在pom文件中添加如下配置：
<properties>
<java.version>11</java.version>
<spring-boot-version>2.7.3</spring-boot-version>
</properties>
<dependencymanagement>
<dependencies>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-dependencies</artifactid>
<version>${spring-boot-version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencymanagement>
删除父项目的src模块，并把pom文件的dependencies标签的文件全部删除，也就是springboot和springboottest的启动依赖。
通过new module，在mongodb-springboot项目中创建web子项目mongodb-test，并在子项目的pom文件中引入如下依赖
<!-- 引入springboot的web依赖 -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- 引入springboot整合mongodb的依赖 -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-data-mongodb</artifactid>
</dependency>
同时父类的pom文件会自动更新为pom类型，并出现modules标签，内部有mongodb-test子模块。
在mongodb-test子模块中的java根目录下，创建包com.zzx，并在包下创建springboot启动类，代码如下：
@springbootapplication
public class mongodbtestapplication {
public static void main(string[] args) {
springapplication.run(mongodbtestapplication.class, args);
}
}
在mongodb-test子模块中的resources目录下创建配置文件application.properties
spring.data.mongodb.host=192.168.126.16 spring.data.mongodb.port=27017 spring.data.mongodb.database=mydb
2.访问mongodb的业务代码实现
在父工程的pom文件的dependencymanagement中引入lombok依赖进行版本管理
<dependency>
<groupid>org.projectlombok</groupid>
<artifactid>lombok</artifactid>
<version>${lombok-version}</version>
</dependency>
在子项目的pom文件中引入lombok依赖
<dependency>
<groupid>org.projectlombok</groupid>
<artifactid>lombok</artifactid>
</dependency>
在com.zzx包下，创建包entity，在该包下创建实体类orders，代码如下
import lombok.*;
import java.io.serializable;
import java.util.date;
@data
@equalsandhashcode
@noargsconstructor
@tostring
public class orders implements serializable {
private string _id;
private string name;
private string size;
private integer price;
private integer quantity;
private date date;
}
2.1 注入mongotemplate使用mongodb
在com.zzx包下，创建包dao，在该包下创建dao层接口orderdao，代码如下：
public interface orderdao{
//根据订单名称查询订单集合
list<orders> findordersbyname(string name);
}
在com.zzx.dao包下，创建包impl，在该包下创建实现类orderdaoimpl，代码如下：
@repository
public class orderdaoimpl implements orderdao {
@autowired
private mongotemplate mongotemplate;
/**
* 按订单名称查询
* @param name
* @return
*/
@override
public list<orders> findordersbyname(string name) {
query query = new query();
query.addcriteria(criteria.where("name").is(name));
return mongotemplate.find(query,orders.class);
}
}
在com.zzx包下，创建包service，在该包下创建service层接口orderservice，代码如下：
public interface orderservice {
// 按订单名称查询
list<orders> findordersbyname(string name);
}
在com.zzx.service包下，创建包impl，在该包下创建实现类orderserviceimpl，代码如下：
@service
public class orderserviceimpl implements orderservice {
@autowired
private orderdao orderdao;
@override
public list<orders> findordersbyname(string name) {
return orderdao.findordersbyname(name);
}
}
在com.zzx包下，创建包controller，在该包下创建controller层ordercontroller，代码如下：
@restcontroller
@requestmapping("orders")
public class ordercontroller {
@autowired
private orderservice orderservice;
@getmapping("/getorders")
public list<orders> findordersbyname(string name)
{
return orderservice.findordersbyname(name);
}
}
2.2 继承mongorepository使用mongodb
在com.zzx包下，创建包repository，在该包下创建接口ordersrepository，代码如下：
public interface ordersrepository extends mongorepository<orders,string> {
/**
* 按订单名称查询订单
* @param name
* @return
*/
list<orders> findordersbyname(string name);
}
mongorepository相当于mybatisplus。
在orderservice接口中，加入如下代码：
list<orders> findordersbyname_2(string name);
在orderserviceimpl实现类中，加入如下代码：
@autowired
private ordersrepository ordersrepository;
@override
public list<orders> findordersbyname_2(string name) {
return ordersrepository.findordersbyname(name);
}
在ordercontroller类中，添加如下代码：
@getmapping("/getorders2")
public list<orders> findordersbyname_2(string name)
{
return orderservice.findordersbyname_2(name);
}
三、mongodb的安全认证及内置角色
1.mongodb的安全认证
mongodb默认是没有账号的，可以直接连接，无须身份验证。实际项目中肯定要权限验证，否则后果不堪设想。
- 进入到容器中，备份数据：
mongodump -h 127.0.0.1:27017 -d mydb -o /usr/local
- 进入到容器中，备份全部数据：
mongodump - 即所有数据库备份文件创建在当前目录的/dump目录下
- 将mongo的dump目录，复制到/usr/local目录：
docker cp mongo5:/dump /usr/local/
- 关闭mongo5容器：
docker stop mongo5
- 以auth方式启动mongodb：
docker run -itd --name mongo6 -p 27017:27017 mongo:5.0.11-focal --auth
- 将备份复制到mongo6：
docker cp /usr/local/dump/ mongo6:/dump
- 进入到mongo6容器：
docker exec -it mongo6 bash
- 进入到mongo命令行客户端，切换到admin数据库。创建mongodb登录用户以及分配权限的方式
db.createuser({
user: "root",
pwd: "123456",
roles:[{role: "root",db:"admin"}]
})
参数：
roles：为用户分配的角色，不同的角色拥有不同的权限，参数是数组，可以同时设置多个role：角色，mongodb已经约定好的角色，不同角色对应不同的权限。db：数据库名称，mongodb默认自带的有admin、local、config、test等，即为数据库实例设置用户
验证用户后可以更改密码、添加角色、恢复数据等操作：db.auth("root","123456")
返回1，即验证成功
- 删除用户：db.dropuser("用户名")
- 修改密码：db.changeuserpassword("root","root")
- 添加角色：db.grantrolestouser("用户名",[{role: "角色名",db: "数据库名"}])
- 恢复数据：mongorestore -h localhost -u root -p 123456 --db mydb /dump/mydb --authenticationdatabase admin
- nosqlbooster可视化连接：
2.mongodb内置角色(role)
read：允许用户读取指定数据库readwrite：允许用户读写指定数据库dbadmin：可以读取任何数据库并对库进行清理、修改、压缩，获取统计信息、执行检查等操作useradmin：可以在指定数据库里创建、删除和管理用户readanydatabase：可以读取任何数据库中的数据，除了数据库config和local之外readwriteanydatabase：可以读写任何数据库中的数据。除了数据库config和local之外useradminanydatabase：可以在任何数据库总创建、删除和管理用户，除了数据库config和local之外dbadminanydatabase：可以读取任何数据库并对库进行清理、修改、压缩，获取统计信息、执行检查等操作，除了数据库config和local之外root：超级账号，超级权限backup：备份数据权限restore：从备份中恢复数据的权限
3.mongodb内置角色的访问控制
创建管理员（即root）
mongodb服务端在开启安全检查之前，至少需要有一个管理员账号，admin数据库中的用户都被视为管理员，如果admin库没有任何用户的话，即使在其他数据库创建了用户，启用身份验证，默认的连接方式依然会有超级权限，即仍然可以不验证账号密码，照样能进行crud，此时的安全认证失效。
在mongo命令行客户端中，首先use admin，然后创建管理员
db.createuser({
user: "root",
pwd: "123456",
roles:[{role: "root",db:"admin"}]
})
创建普通用户
创建有读写权限的用户zhangsan，指定数据库mydb
db.createuser({
user: "zhangsan",
pwd: "123456",
roles:[{role: "readwrite",db:"mydb"}]
})
创建有读权限的用户lisi，指定数据库mydb
db.createuser({
user: "lisi",
pwd: "123456",
roles:[{role: "read",db:"mydb"}]
})
验证用户zhangsan，此时需要先退出客户端重新进入，否则会出现验证2个用户名的错误：db.auth("zhangsan","123456")
- 插入数据：
db.c1.insert({name:"testdb1"}) - 查询集合c1所有文档：
db.c1.find() - 即只有mydb的读写权限
先use mydb，验证用户lisi：db.auth("lisi","123456")
- 查询集合c1所有文档：
db.c1.find() - 即只有mydb的读权限
总结
java连接mongodb,将mongodb服务器的ip地址及端口号再加上一些参数单独写在properties文件中或者通过edit ciguration配置，在程序中读出来，通过mongoclients创建连接，再通过mangoclient获取数据库。
springboot连接mongodb，在配置文件中指定ip地址及端口号和数据库名；调用mongotemplate函数进行查询操作即可。而不用手动去读取配置文件，再获取数据库及集合。而是交给springboot来做，甚至都不用指定集合，springboot应该是首先通过实体类名去找对应的集合。
springboot整合mongodb可以使用两种方式，mongotemplate以及mongorepository。
mongotemplate方式需要dao层的实现类去实现；而mongorepository方式则不需要定义实现类，但是需要dao层去继承mongorepository并指定其实体类及查询条件类型。
在创建超级权限用户时，需要use admin。
进行权限验证之前，要先use database(对应的数据库)，才可以进行权限验证。
更改密码、添加角色、恢复数据等操作需要权限验证。
权限验证后，可以进行show dbs，查看自己有权限的数据库。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论