java 传mongo中文乱码 mongo java driver

转载

锦绣前程未央 2023-09-21 07:10:13

文章标签 java 传mongo中文乱码数据库 java json System 文章分类 Java 后端开发

本文总结来自MongoDB 的java版本的Driver(驱动) api入门指南

官网地址:https://docs.mongodb.org/getting-started/java/client/

MongoDB 一个开源的文档型数据库，提供高性能，高可用，自动切片的特性。

准备工作

首先我们需要下载一个MongoDB,我嫌麻烦就下载了一个社区版本，编译好的解压就能用。

curl -O https://fastdl.mongodb.org/osx/mongodb-osx-x86_64-3.2.4.tgz

解压启动

tar -zxvf mongodb-osx-x86_64-3.2.4.tgz

直接启动./mongod 的话会出现下面的错误，错误中包含下面提示信息

Data directory /data/db not found

这是因为MongoDB 默认会将数据文件放在/data/db下，我们可以指向其他存在的目录，比如说我们在安装目录下保存数据文件

mkdir -p /work/mongodb-osx-x86_64-3.2.4/dbpath

所以接下来我们可以这样启动

./mongod --dbpath /work/mongodb-osx-x86_64-3.2.4/dbpath

代码很简单，直接上代码，重要的地方说明下即可

一、连接

public static void main(String[] args) {
		String dbName = "myDb";
		String collectionName = "myTable";
		try {
			testMongo(dbName, collectionName);
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}

	public static void testMongo(String dbName, String collectionName) throws ParseException {
		MongoClient mc = new MongoClient("192.168.2.6", 27017);
		//获取数据库，不用担心之前没有，没有的话会创建一个
		MongoDatabase database = mc.getDatabase(dbName);

		testCollection(database, collectionName);
		mc.close();
	}

	public static void testCollection(MongoDatabase database, String collectionName) throws ParseException {
		//获取数据集合，可以理解为一个表，不用担心之前没有，没有的话会创建一个
		MongoCollection<Document> collection = database.getCollection(collectionName);

		insert(collection);
		find(collection);
		update(collection);
		remove(collection);

	}

二、插入数据

public static void insert(MongoCollection<Document> collection) throws ParseException {
		collection.drop();// 每次插入前把之前的数据全部删除

		DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ENGLISH);
		collection.insertOne(new Document("address", new Document().append("street", "1 Avenue").append("zipcode", "10075").append("building", "1481")
				.append("coord", asList(-73.9557413, 40.7720266)))
				.append("borough", "Manhattan")
				.append("cuisine", "Italian")
				.append("grades",
						asList(new Document().append("date", format.parse("2014-10-01T00:00:00Z")).append("grade", "A").append("score", 12), new Document()
								.append("date", format.parse("2014-01-16T00:00:00Z")).append("grade", "B").append("score", 13))).append("name", "Vella")
				.append("restaurant_id", "41704621"));

		collection.insertOne(new Document("address", new Document().append("street", "2 Avenue").append("zipcode", "10076").append("building", "1482")
				.append("coord", asList(-73.9557413, 40.7720266)))
				.append("borough", "Manhattan")
				.append("cuisine", "Italian")
				.append("grades",
						asList(new Document().append("date", format.parse("2014-10-01T00:00:00Z")).append("grade", "A").append("score", 14), new Document()
								.append("date", format.parse("2014-01-16T00:00:00Z")).append("grade", "C").append("score", 15))).append("name", "Bruce")
				.append("restaurant_id", "41704622"));

		collection.insertOne(new Document("address", new Document().append("street", "3 Avenue").append("zipcode", "10077").append("building", "1483")
				.append("coord", asList(-73.9557413, 40.7720266)))
				.append("borough", "Manhattan")
				.append("cuisine", "Italian")
				.append("grades",
						asList(new Document().append("date", format.parse("2014-10-01T00:00:00Z")).append("grade", "B").append("score", 16), new Document()
								.append("date", format.parse("2014-01-16T00:00:00Z")).append("grade", "C").append("score", 17))).append("name", "Aline")
				.append("restaurant_id", "41704623"));
	}

三、查找

public static void find(MongoCollection<Document> collection) {
		/* 查询所有 */
		System.out.println("\n 查询所有");
		FindIterable<Document> find = collection.find();
		find.forEach(getShower());

		/* 顶层的查询 ，将整个数据看成一个格式化好的json来理解 */
		System.out.println("\n 顶层的查询 ，将整个数据看成一个格式化好的json来理解");
		FindIterable<Document> iterable = collection.find(new Document("borough", "Manhattan"));
		iterable.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter来完成查询,和上一个查询等价");
		FindIterable<Document> find2 = collection.find(Filters.eq("borough", "Manhattan"));
		find2.forEach(getShower());

		/* 非顶层店查询 */
		System.out.println("\n 非顶层的查询 ，将整个数据看成一个格式化好的json来理解");
		FindIterable<Document> find3 = collection.find(new Document("address.zipcode", "10075"));
		find3.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter来完成查询,和上一个查询等价");
		FindIterable<Document> find4 = collection.find(Filters.eq("address.zipcode", "10075"));
		find4.forEach(getShower());

		System.out.println("\n 非顶层的在某个数组中查询 ，将整个数据看成一个格式化好的json来理解");
		FindIterable<Document> find5 = collection.find(new Document("grades.grade", "B"));
		find5.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter来完成查询,和上一个查询等价");
		FindIterable<Document> find6 = collection.find(Filters.eq("grades.grade", "B"));
		find6.forEach(getShower());

		/* 自定义查询 */
		System.out.println("\n 自定义的查询 利用$gt(great than)");
		FindIterable<Document> find7 = collection.find(new Document("grades.score", new Document("$gt", 30)));
		find7.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter.gt 来完成查询,和上一个查询等价");
		FindIterable<Document> find8 = collection.find(Filters.gt("grades.score", 30));
		find8.forEach(getShower());
		System.out.println("\n 自定义的查询 利用$lt(less than)");
		FindIterable<Document> find9 = collection.find(new Document("grades.score", new Document("$lt", 15)));
		find9.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter.lt 来完成查询,和上一个查询等价");
		FindIterable<Document> find10 = collection.find(Filters.lt("grades.score", 15));
		find10.forEach(getShower());

		/* 组合查询 */
		System.out.println("\n 组合查询 and");
		FindIterable<Document> find11 = collection.find(new Document("cuisine", "Italian").append("address.zipcode", "10075"));
		find11.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter.and 来完成组合查询,和上一个查询等价");
		FindIterable<Document> find12 = collection.find(Filters.and(Filters.eq("cuisine", "Italian"), Filters.eq("address.zipcode", "10075")));
		find12.forEach(getShower());
		System.out.println("\n 组合查询 or");
		FindIterable<Document> find13 = collection.find(new Document("$or",
				asList(new Document("cuisine", "Italian"), new Document("address.zipcode", "10075"))));
		find13.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter.or 来完成组合查询,和上一个查询等价");
		FindIterable<Document> find14 = collection.find(Filters.or(Filters.eq("cuisine", "Italian"), Filters.eq("address.zipcode", "10075")));
		find14.forEach(getShower());

		/* 查询后的排序 */
		System.out.println("\n 通过在查询的结果集后调用sort来完成排序");
		FindIterable<Document> find15 = collection.find().sort(new Document("borough", 1).append("address.zipcode", 1));
		find15.forEach(getShower());
		System.out.println("\n 利用mongo自带的filter.sort 来完成排序,和上一个查询等价");
		FindIterable<Document> find16 = collection.find().sort(Sorts.ascending("borough", "address.zipcode"));
		find16.forEach(getShower());
	}

上面代码中的一些小的工具方法

public static void showall(MongoCollection<Document> collection) {
		System.out.println("\n 查询所有");
		FindIterable<Document> find = collection.find();
		find.forEach(getShower());
	}

	public static Block<Document> getShower() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return new Block<Document>() {
			public void apply(final Document document) {
				System.out.println(document);
			}
		};
	}

四、更新

public static void update(MongoCollection<Document> collection) {
		/* 更新顶层节点 ,使用了内置函数 $set , $currentDate */
		System.out.println("\n更新顶层节点 ,使用了内置函数 $set , $currentDate 更新之前");
		showall(collection);
		collection.updateOne(new Document("name", "Aline"),
				new Document("$set", new Document("cuisine", "American (New)")).append("$currentDate", new Document("lastModified", true)));
		System.out.println("更新之后\n");
		showall(collection);

		/* 更新非顶层节点,使用了内置函数 $set */
		System.out.println("\n更新非顶层节点,使用了内置函数 $set 更新之前");
		showall(collection);
		collection.updateOne(new Document("restaurant_id", "41704622"), new Document("$set", new Document("address.street", "East 31st Street")));
		System.out.println("更新之后\n");
		showall(collection);

		/* 更新多个 ,使用的是append 函数 */
		System.out.println("\n更新多个 ,使用的是append ,$set ,$lastModified 函数 更新之前");
		showall(collection);
		collection.updateMany(new Document("address.zipcode", "10075").append("cuisine", "Italian"), new Document("$set", new Document("cuisine",
				"Category To Be Determined")).append("$currentDate", new Document("lastModified", true)));
		System.out.println("更新之后\n");
		showall(collection);

		/* 替换 */
		System.out.println("\n替换 ,可以理解为通过前面的条件查询到_id，对应的记录然后整个替换这条记录");
		showall(collection);
		collection.replaceOne(
				new Document("restaurant_id", "41704622"),
				new Document("address", new Document().append("street", "2 Avenue").append("zipcode", "10075").append("building", "1480")
						.append("coord", asList(-73.9557413, 40.7720266))).append("name", "Vella 2"));
		System.out.println("更新之后\n");
		showall(collection);
	}

五、删除

public static void remove(MongoCollection<Document> collection) {
		/* 删除 */
		System.out.println("\n删除符合条件的数据,删除之前的数据如下");
		showall(collection);
		collection.deleteMany(new Document("borough", "Manhattan"));
		System.out.println("删除之后的数据如下");
		showall(collection);
		System.out.println("\n删除所有数据,删除之前的数据如下");
		showall(collection);
		collection.deleteMany(new Document());
		System.out.println("删除之后的数据如下");
		showall(collection);

		System.out.println("\n删除整个集合,包括集合中的数据和索引");
		showall(collection);
		collection.drop();
		System.out.println("删除之后的数据如下");
		showall(collection);
	}

六、补上加索引

public static void index(MongoCollection<Document> collection) {
		System.out.println("\n创建单个索引");
		collection.createIndex(new Document("cuisine", 1));

		System.out.println("\n创建索引");
		collection.createIndex(new Document("cuisine", 1).append("address.zipcode", -1));
	}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。