java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > IDEA操作MongoDB及安全认证

IDEA操作MongoDB及安全认证方式

作者:帅得真的是无敌了

这篇文章主要介绍了IDEA操作MongoDB及安全认证方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

一、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
docker cp mongo5:/dump /usr/local/
docker stop mongo5
docker run -itd --name mongo6 -p 27017:27017 mongo:5.0.11-focal --auth
docker cp /usr/local/dump/ mongo6:/dump
docker exec -it mongo6 bash
db.createUser({
	user: "root",
	pwd: "123456",
	roles:[{role: "root",db:"admin"}]
})

参数:

验证用户后可以更改密码、添加角色、恢复数据等操作:db.auth("root","123456")

返回1,即验证成功

2.MongoDB内置角色(role)

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")

先use mydb,验证用户lisi:db.auth("lisi","123456")

总结

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,查看自己有权限的数据库。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文