您可以捐助,支持我们的公益事业。

1元 10元 50元





认证码:  验证码,看不清楚?请点击刷新验证码 必填



  求知 文章 文库 Lib 视频 iProcess 课程 角色 咨询 工具 讲座 Modeler   Code  
会员   
 
   
 
  
每天15篇文章
不仅获得谋生技能
更可以追随信仰
 
 
     
   
 订阅
  捐助
MongoDB学习笔记
 
作者:limingnihao 来源:ITeYe 发布于 2015-11-10
1822 次浏览     评价:      
 

第1章 MongoDB的安装

1.1 MongoDB简介

MongoDB是一个基于分布式文件存储的数据库开源项目。由C++语言编写,旨在为WEB应用提供可护展的高性能数据存储解决方案。

它的特点是可扩展,高性能,易使用,模式自由,存储数据非常方便等。

1.1.1 主要功能特性

a)面向文档存储:(类JSON数据模式简单而强大)。

b)高效的传统存储方式:支持二进制数据及大型对象(如照片和视频)。

c)复制及自动故障转移:Mongo数据库支持服务器之间的数据复制,支持主-从模式及服务器之间的相互复制。

d)Auto-Sharding自动分片支持云级扩展性(处于早期alpha阶段):自动分片功能支持水平的数据库集群,可动态添加额外的机器。

e)动态查询:它支持丰富的查询表达式。查询指令使用JSON形式的标记,可轻易查询文档中内嵌的对象及数组。

f)全索引支持:包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式,并生成一个高效的查询计划。

g)支持RUBY,PYTHON,JAVA,C++,PHP等多种语言。

1.1.2 适用场景

a)适合实时的插入,更新与查询,并具备应用程序实时数据存储所需的复制及高度伸缩性。

b)适合作为信息基础设施的持久化缓存层。

c)适合由数十或数百台服务器组成的数据库。因为Mongo已经包含对MapReduce引擎的内置支持。

d)Mongo的BSON数据格式非常适合文档化格式的存储及查询。

1.1.3 不适用场景

a)高度事务性的系统。

b)传统的商业智能应用。

c)级为复杂的SQL查询。

1.2 Windows环境安装

1.2.1 下载tar包

mongodb-win32-x86_64-2.4.6。

1.2.2 配置文件

创建log文件夹

md D:\mongodb-win32-x86_64-2.4.6 \log

创建MongoDB的logpath选项的配置文件:

echo logpath=d:\mongodb-win32-x86_64-2.4.6\log\mongo.log > d:\mongodb-win32-x86_64-2.4.6\mongod.cfg  

1.2.3 手动启动

启动服务

mongod --dbpath d:\mongodb_data  

mongod --config d:\mongodb-win32-x86_64-2.4.6\mongod.cfg

1.2.4 服务启动

安装 MongoDB 程序作为Windows 服务。

安装 MongoDB 服务  
mongod --config d:\mongodb-win32-x86_64-2.4.6\mongod.cfg --install

运行 MongoDB 服务
net start MongoDB

移除服务
mongod --remove

1.2.5 REST is not enabled

当出现以下错误时

REST is not enabled. use --rest to turn on. check that port 28017 is secured for the network too.

解决办法:

使用命令行启动时:

mongod --dbpath d:\mongodb_data  --rest --port 27017

重新安装系统服务:

mongod --dbpath d:\mongodb_data --config d:\mongodb-win32-x86_64-2.4.6\mongod.cfg --rest --port 27017 --install 

1.3 Linux环境安装

1.3.1 下载包tgz

mongodb-linux-i686-2.4.6.tgz

1.3.2 创建用户

创建用户

adduser mongodb   
passwd mongodb

1.3.3 创建数据库文件

创建数据库文件

mkdir -p /data/mongodb_data  
chown mongodb /data/mongodb_data –R
chgrp mongodb /data/mongodb_data -R

1.3.4 配置文件

创建log文件夹

mkdir /opt/mongodb/mongodb-linux-i686-2.4.6/logs 

创建MongoDB的logpath选项的配置文件:

echo /opt/mongodb/mongodb-linux-i686-2.4.6/bin/mongod --dbpath /data/mongodb_data/
 --logpath /opt/mongodb/mongodb-linux-i686-2.4.6/logs/mongodb.log --rest --port 27017  

1.3.5 手动启动

启动服务

这里有点要特别说明的地方

1.3.6 服务启动

安装 MongoDB 程序作为Linux 服务。

安装 MongoDB 服务

echo /opt/mongodb/mongodb-linux-i686-2.4.6/bin/mongod --dbpath 
/data/mongodb_data/ --logpath /opt/mongodb/mongodb-linux-i686-2.4.6/logs
/mongodb.log --rest --port 27017–fork >> /etc/rc.local  

1.4 链接数据库

使用命令行方式,并创建student数据库

命令行链接病创建数据库

>mongo  
>use student

在Student数据库中,创建user集合,插入一条文档

在Student数据库插入一条数据并查询

db.user.save({username: "limingnihao", nickname: "黎明你好", password: "123456"}) 

1.5 操作命令

1.6 数据类型

ObjectId类型结构:

第2章 MongoDB的增删改查

MongoDB中数据的基本单元叫做文档,采用json的键-值的方式。多个键及其关联的值有序的存放在一起变是文档。类似于编程语言中的键值关系。MongoDB文档都是BSON文档,他是一个JSON的二进制形式。

MongoDB的文档

MongoDB中文档被存储在集合中。集合是一组有关系索引的文档。集合类似于关系数据库中的表。

MongoDB的集合

2.1 方法参考

查询游标方法

2.2 Insert()

db.collection.insert(document)  

Insert()方法有以下行为:

如果该集合不存在,insert()方法将创建集合。

如果文档没有指定一个_id后缀字段,然后 MongoDB 将添加一个_id字段并使用ObjectId为文档分配取值。

如果文档需要增加一个新的字段,则insert()方法可以为文档插入新的字段。这不需要更改集合的数据模型或现有的文档。

db.user.insert({_id: "1", name:{username: "limingnihao", nickname: "黎明你好"}, password: "123456"})  
db.user.insert({_id: "2", name:{username: "zhoujielun", nickname: "周杰伦"}, password: "123456", birth: ISODate('1979-01-18')})
db.user.insert({_id: "3", name:{username: "caiyilin", nickname: "蔡依林"}, password: "123456", birth: ISODate('1980-09-15'), special:["看我72变", "花蝴蝶", "特务J"], regionName: "台湾"})

2.3 Save()

db.collection.save(document)  

插入一个新的文档,或者根据其文档的参数更新现有的文档。

如果文档不包含一个_id的字段进行save时,mongod将向文档中添加一个_id字段并将其分配一个ObjectId。

如果文档中包含一个_id字段和值进行save ()方法时,则在集合中查询此_id的文档执行的是upsert操作。如果集合中不存在具有指定的_id值的文档,save ()方法执行的是insert操作。save ()方法执行时会将现有文档中的所有字段都替换为新文档中字段。

db.user.save({_id: "1", name:{username: "limingnihao", nickname: "黎明你好"}, password: "123456", birth: ISODate('1985-07-15')})  

2.4 Update()

db.collection.update( <query>, <update>, <upsert>, <multi> )  

修改现有存在的文档或集合时使用。

默认的update()方法值更新单个文档。但是如果multi参数设置为true,则更新操作可以更新全部符合条件的文档。

Query – 类型:文档;用于更新选择过滤。

Update – 类型:文档;需要更新的文档的内容。

Upsert – 类型:文档或boolean;设置为true时,当查询没有匹配到文档时进行新建。默认值为false

Multi: - 类型:文档或boolean;设置为true时,则更新满足查询条件的所有文档(多个)。设置为false时只更新单个文档。默认为false。

字段更新操作方式

db.user.update({_id: "1"}, {$inc:{age: 1}}, {multi:true})  
db.user.update({_id: "1"}, { $rename: { 'password': 'pwd'}})
db.user.update({_id: "4"}, { $setOnInsert: { works: 5}}, {upsert: true})
db.user.update({_id: "1"}, {$set:{password: "654321", age: 28}})
db.user.update({_id: "4"},{$unset: {"works": 5 }})

2.5 Find()

db.collection.find(<criteria>, <projection>)  
db.collection.findOne(<criteria>, <projection>)

Criteria - 类型:文档;可选,文档的查询过滤条件。

Projection - 类型:文档,对结果进行字段匹配,{ field1: <boolean>, field2: <boolean> ... }。

后面还可以:Sort()排序、Limit()限制个数、Skip()起始点。

db.collection.find(<criteria>, <projection>)返回集合  
db.collection.findOne(<criteria>, <projection>)返回一个
db.user.find({_id: "1"})
db.user.find({works: 5})
db.user.find().sort({age:1})
db.user.find().limit(2).sort({age:1})
db.user.find().skip(1).limit(2).sort({age:1})

2.6 Remove()

db.collection.remove(query, justOne)  

Query – 类型:文档;用于删除选择过滤。

JustOne – 类型:boolean;当设置为true时只删除一个文档。

db.user.remove({_id: "4"}, true)  

2.7 Count()

db.collection.count(<query>)  

Query – 类型:文档;用于查询选择过滤。

db.user.count({age: 1})  

2.8 Distinct()

db.collection.distinct(field, query) 

Field – 类型:字符串;返回非重复的字段。

Query – 类型:文档;查询条件。

db.user.distinct("_id", {age: 1})

第3章 MongoDB的Java驱动

3.1 下载Java驱动

3.1.1 Jar包

http://central.maven.org/maven2/org/mongodb/mongo-java-driver/

3.1.2 Maven

<dependency>  
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>2.10.1</version>
<type>jar</type>
<scope>compile</scope>
</dependency>

3.2 基本操作

3.2.1 基本操作

String myUserName = "admin";  
String myPassword = "admin";
MongoClient mongoClient = new MongoClient("localhost", 27017);

// 1.数据库列表
for (String s : mongoClient.getDatabaseNames()) {
System.out.println("DatabaseName=" + s);
}

// 2.链接student数据库
DB db = mongoClient.getDB("student");
mongoClient.setWriteConcern(WriteConcern.JOURNALED);

// 3.用户验证
boolean auth = db.authenticate(myUserName, myPassword.toCharArray());
System.out.println("auth=" + auth);

// 4.集合列表
Set<String> colls = db.getCollectionNames();
for (String s : colls) {
System.out.println("CollectionName=" + s);
}

// 5.获取摸个集合对象
DBCollection coll = db.getCollection("user");

3.2.2 新增

BasicDBObject doc = new BasicDBObject("_id", "6").append("name", new BasicDBObject("username", "limingnihao")
.append("nickname", "黎明你好")).append("password", "123456")  
.append("password", "123456").append("regionName", "北京").append("works", "5").append("birth", new Date());
WriteResult result = coll.insert(doc);

System.out.println("insert-result: " + result);

3.2.3 查询

// 2.1查询 - one  
DBObject myDoc = coll.findOne();
System.out.println(myDoc);

// 2.2 查询 - 数量
System.out.println(coll.getCount());

// 2.3查询 - 全部
DBCursor cursor = coll.find();
while (cursor.hasNext()) {
System.out.println("全部--------" + cursor.next());
}

// 2.4查询 - 过滤 - 等于
BasicDBObject query = new BasicDBObject("age", 1);
cursor = coll.find(query);
while (cursor.hasNext()) {
System.out.println("age=1--------" + cursor.next());
}

// 2.5查询 - 过滤条件 - 不等于
query = new BasicDBObject("age", new BasicDBObject("$ne", 1));
cursor = coll.find(query);
while (cursor.hasNext()) {
System.out.println("age!=1" + cursor.next());
}

// 2.6查询 - 过滤条件 - 20 < i <= 30
query = new BasicDBObject("age", new BasicDBObject("$gt", 20).append("$lte", 30));
cursor = coll.find(query);
while (cursor.hasNext()) {
System.out.println("20<age<=30" + cursor.next());
}

3.2.4 修改

DBObject search = coll.findOne(new BasicDBObject("_id", "5"));  
BasicDBObject object = new BasicDBObject().append("$set", new BasicDBObject ("password", "1211111")).append("$set", new BasicDBObject("birth", new Date()));
WriteResult result = coll.update(search, object, true, true);
System.out.println("update-result: " + result);

3.2.5 删除

DBObject search = coll.findOne(new BasicDBObject("_id", "6"));  
WriteResult result = coll.remove(search);
System.out.println("remove-result: " + result);

3.3 Java驱动并发

Java MongoDB驱动程序是线程安全的。如果在Web服务器环境中使用,那么应该创建一个MongoClient实例全局使用。MongoClient内部维护了数据库的连接池(默认连接池大小为10)。每次DB请求(查询、插入等)的Java线程将从连接池中获取链接并进行支持,然后释放连接。每次使用连接是不相同的。

在复制(replica)模式下,如果设置slaveOK选项为on,那么读操作会被均匀的分布到各个slave上。这意味着对于同一个线程,一个写操作后紧跟着的一个读操作,有可能被发送到不同的服务器上(写操作发送到master上,读操作发送到slave上),这样读操作有可能不会立刻反映出上一个写操作的数据(因为主从的异步性)。

如果你想要确保在一个session中完整的一致性(例如在一个http请求中),你可能希望java驱动是用同一个socket连接,这时你可以通过使用"consistent request"来达到目的——在操作前后分别调用requestStart()和requestDone()。

DB和DBCollection完全是线程安全的。事实上,你不管怎么样调用都是同一实例,因为他们进行了缓存。

DB db...;  
db.requestStart();
try {
db.requestEnsureConnection();
code....
} finally {
db.requestDone();
}

在单独写操作上的WriteConcern选项

默认情况下,每次写操作后,连接就被释放回连接池——此时你调用getLastError()是没用的。

所以可以采用两种方式:

1,使用类似WriteConcern.SAFE这样的写策略来代替默认策略,这样java驱动会自动首先调用getLastError(),然后才将连接放回连接池。

DBCollection coll...;  
coll.insert(..., WriteConcern.SAFE);

2,采用上述的requestStart()和requestDone()方式来维持连接不被释放,中间调用getLastError()获取错误信息。

DBCollection coll...;  
coll.insert(..., WriteConcern.SAFE);
DB db...;
DBCollection coll...;
db.requestStart();
try {
coll.insert(...);
DBObject err = db.getLastError();
} finally {
db.requestDone();
}

第4章 MongoDB整合Spring

4.1.1 repositories

创建maven项目,其中repositories使用spring的maven库:

<repositories>  
<repository>
<id>central</id>
<name>Maven Central</name>
<url>http://repo1.maven.org/maven2/</url>
</repository>
<repository>
<id>spring-release</id>
<name>Spring Maven Release Repository</name>
<url>http://repo.springsource.org/libs-release</url>
</repository>
<repository>
<id>atlassian-m2-repository</id>
<url>https://m2proxy.atlassian.com/repository/public</url>
</repository>
</repositories>

4.1.2 Dependencies

使用到的jar包:

<dependencies>  
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<type>jar</type>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
<type>jar</type>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>2.10.1</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>1.2.1.RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb-cross-store</artifactId>
<version>1.2.1.RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb-log4j</artifactId>
<version>1.2.1.RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>

4.2 添加spring配置文件

spring的配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/data/mongo
http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="liming.mongodb.example" />

<mongo:mongo host="127.0.0.1" port="27017" />

<!-- mongo的工厂,通过它来取得mongo实例,dbname为mongodb的数据库名,没有的话会自动创建 -->
<mongo:db-factory dbname="student" mongo-ref="mongo" />

<!-- mongodb的主要操作对象,所有对mongodb的增删改查的操作都是通过它完成 -->
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
</bean>

<!-- 映射转换器,扫描back-package目录下的文件,根据注释,把它们作为mongodb的一个collection的映射 -->
<mongo:mapping-converter base-package="climing.mongodb.example.data.model" />

<!-- mongodb bean的仓库目录,会自动扫描扩展了MongoRepository接口的接口进行注入 -->
<mongo:repositories base-package="liming.mongodb.example.data.impl" />

<context:annotation-config />

</beans>

4.3 增删改查

Userl实现的增删改查:

4.3.1 UserEntity

package liming.mongodb.example.data.model;  

import java.util.Date;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "user")
public class UserEntity {

@Id
private String id;
private NameEntity name;
private int age;
private int works;
private Date birth;
private String password;
private String regionName;
private String[] special;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public NameEntity getName() {
return name;
}

public void setName(NameEntity name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public int getWorks() {
return works;
}

public void setWorks(int works) {
this.works = works;
}

public Date getBirth() {
return birth;
}

public void setBirth(Date birth) {
this.birth = birth;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getRegionName() {
return regionName;
}

public void setRegionName(String regionName) {
this.regionName = regionName;
}

public String[] getSpecial() {
return special;
}

public void setSpecial(String[] special) {
this.special = special;
}

}

4.3.2 NameEntity

package liming.mongodb.example.data.model;  

public class NameEntity {

private String username;

private String nickname;

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getNickname() {
return nickname;
}

public void setNickname(String nickname) {
this.nickname = nickname;
}

}

4.3.3 UserDaos

package liming.mongodb.example.data;  

import java.util.List;

import liming.mongodb.example.data.model.UserEntity;

import org.springframework.transaction.annotation.Transactional;

@Transactional
public interface UserDao {

public abstract void _test();

public abstract void createCollection();

public abstract List<UserEntity> findList(int skip, int limit);

public abstract List<UserEntity> findListByAge(int age);

public abstract UserEntity findOne(String id);

public abstract UserEntity findOneByUsername(String username);

public abstract void insert(UserEntity entity);

public abstract void update(UserEntity entity);

}

4.3.4 UserDaoImpl

package liming.mongodb.example.data.impl;  

import java.util.List;
import java.util.Set;

import liming.mongodb.example.data.UserDao;
import liming.mongodb.example.data.model.UserEntity;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import com.mongodb.DB;

@Repository
public class UserDaoImpl implements UserDao {

public static final Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);

@Autowired
private MongoTemplate mongoTemplate;

@Override
public void _test() {
Set<String> colls = this.mongoTemplate.getCollectionNames();
for (String coll : colls) {
logger.info("CollectionName=" + coll);
}
DB db = this.mongoTemplate.getDb();
logger.info("db=" + db.toString());
}

@Override
public void createCollection() {
if (!this.mongoTemplate.collectionExists(UserEntity.class)) {
this.mongoTemplate.createCollection(UserEntity.class);
}
}

@Override
public List<UserEntity> findList(int skip, int limit) {
Query query = new Query();
query.with(new Sort(new Order(Direction.ASC, "_id")));
query.skip(skip).limit(limit);
return this.mongoTemplate.find(query, UserEntity.class);
}

@Override
public List<UserEntity> findListByAge(int age) {
Query query = new Query();
query.addCriteria(new Criteria("age").is(age));
return this.mongoTemplate.find(query, UserEntity.class);
}

@Override
public UserEntity findOne(String id) {
Query query = new Query();
query.addCriteria(new Criteria("_id").is(id));
return this.mongoTemplate.findOne(query, UserEntity.class);
}

@Override
public UserEntity findOneByUsername(String username) {
Query query = new Query();
query.addCriteria(new Criteria("name.username").is(username));
return this.mongoTemplate.findOne(query, UserEntity.class);
}

@Override
public void insert(UserEntity entity) {
this.mongoTemplate.insert(entity);

}

@Override
public void update(UserEntity entity) {
Query query = new Query();
query.addCriteria(new Criteria("_id").is(entity.getId()));
Update update = new Update();
update.set("age", entity.getAge());
update.set("password", entity.getPassword());
update.set("regionName", entity.getRegionName());
update.set("special", entity.getSpecial());
update.set("works", entity.getWorks());
update.set("name", entity.getName());
this.mongoTemplate.updateFirst(query, update, UserEntity.class);

}

}

4.3.5 测试代码

package liming.mongodb.example;  

import java.util.Arrays;
import java.util.Date;
import java.util.List;

import liming.mongodb.example.data.UserDao;
import liming.mongodb.example.data.impl.UserDaoImpl;
import liming.mongodb.example.data.model.UserEntity;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationSpring {

public static void main(String[] args) {

System.out.println("Bootstrapping HelloMongo");

ConfigurableApplicationContext context = null;
context = new ClassPathXmlApplicationContext("applicationContext.xml");

UserDao userDao = context.getBean(UserDaoImpl.class);
userDao._test();
UserEntity entity1 = new UserEntity();
entity1.setId("5");
entity1.setAge(1);
entity1.setBirth(new Date());
entity1.setPassword("asdfasdf");
entity1.setRegionName("北京");
entity1.setWorks(1);
userDao.insert(entity1);
userDao.update(entity1);
userDao.createCollection();

List<UserEntity> list = userDao.findList(0, 10);
for (UserEntity e : list) {
System.out.println("all - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial()) + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());
}

list = userDao.findListByAge(1);
for (UserEntity e : list) {
System.out.println("age=1 - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial()) + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());
}

UserEntity e = userDao.findOne("1");
System.out.println("id=1 - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial())
+ ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());

e = userDao.findOneByUsername("limingnihao");
System.out.println("username=limingnihao - id=" + e.getId() + ", age=" + e.getAge() + ", password=" + e.getPassword() + ", regionName=" + e.getRegionName() + ", special=" + Arrays.toString(e.getSpecial()) + ", name=" + e.getName().getUsername() + "-" + e.getName().getNickname() + ", birth=" + e.getBirth());

System.out.println("DONE!");
}

}
   
1822 次浏览  评价: 差  订阅 捐助
相关文章

我们该如何设计数据库
数据库设计经验谈
数据库设计过程
数据库编程总结
 
相关文档

数据库性能调优技巧
数据库性能调整
数据库性能优化讲座
数据库系统性能调优系列
相关课程

高性能数据库设计与优化
高级数据库架构师
数据仓库和数据挖掘技术
Hadoop原理、部署与性能调优
 

MySQL索引背后的数据结构
MySQL性能调优与架构设计
SQL Server数据库备份与恢复
让数据库飞起来 10大DB2优化
oracle的临时表空间写满磁盘
数据库的跨平台设计
更多...   

并发、大容量、高性能数据库
高级数据库架构设计师
Hadoop原理与实践
Oracle 数据仓库
数据仓库和数据挖掘
Oracle数据库开发与管理

GE 区块链技术与实现培训
航天科工某子公司 Nodejs高级应用开发
中盛益华 卓越管理者必须具备的五项能力
某信息技术公司 Python培训
某博彩IT系统厂商 易用性测试与评估
中国邮储银行 测试成熟度模型集成(TMMI)
中物院 产品经理与产品管理
更多...   
 
 
 
 
 
每天2个文档/视频
扫描微信二维码订阅
订阅技术月刊
获得每月300个技术资源
 
 

关于我们 | 联系我们 | 京ICP备10020922号 京公海网安备110108001071号