Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.
1 | $ hexo new "My New Post" |
More info: Writing
1 | $ hexo server |
More info: Server
1 | $ hexo generate |
More info: Generating
1 | $ hexo deploy |
More info: Deployment
概念:
将数据集中与要预测的值没有因果关系或者因果关系不大，或者冗余的特征去除，选取出对要预测的值关系密切的特征。
好处:
性能提升/提高模型的准确率
根据单个特征的在整个数据集中的方差直接选择
当某个特征在样例中方差越小时，也就是说它的一致性越高，对于整个的分类作用也就越小，当它小于 threshold时，我们就可以去除这个特征。
在sklearn中用来 VarianceThreshold 来提取。
1 | from sklearn.feature_selection import VarianceThreshold |
单变量特征选择:Univariate feature selection
上面的根据方差来选择特征显然太naive了，在单变量特征选择中，我们通过一些统计度量方法来选择。
SelectKBest:从特征值中选取K个最好的特征SelectPercentile：从特征值中选取一定比例的特征对每个变量使用常用的单变量统计测试: 假阳性率(false positive rate)SelectFpr,伪发现率(false discovry rate)SelectFdr,或者族系误差(family wise error)SelectFwe。
统计度量方法根据预测值可以分为两类：
回归: f_regression, mutual_info_regression
分类: chi2, f_classif, mutual_info_classif
以SelectKBest为例:
1 | from sklearn.feature_selection import SelectKBest,f_classif |
OutPut：
1 | (150, 3) |
//在接着介绍sklearn的feature_selection模块前，先介绍一下有关特征选取的常用的两个过程。
分两个部分介绍：
coef_属性 或者feature_importances_属性获得每个特征的重要性，注意先归一化，去除掉最不重要的属性，知道满足要求。提供的recursive feature elimination (RFE)函数:
- `RFE`:自动寻找到要求到的feature数量。
- `RFECV`:在一个交叉验证循环中自动找到最优的feature数量。
总的来说类似上面的递归式特征消除，不过在子集评价中不是去掉最不重要的特征，而是去掉所有coef_属性 或者feature_importances_属性低于阀值的特征。
基于L1正则选取。
线性模型的L1正则会产生稀疏解，可以用此选取特征。可以用于此目的的稀疏评估器有用于回归的 linear_model.Lasso , 以及用于分类的 linear_model.LogisticRegression 和 svm.LinearSVC
在 SVM 和逻辑回归中，参数 C 是用来控制稀疏性的：小的 C 会导致少的特征被选择。使用 Lasso，alpha 的值越大，越少的特征会被选择。
Tree-based feature selection（基于树的特征选取）
树可以产生每个feature的重要性，因此也可用于特征选取，与SelectFromModel结合使用。
##
sklearn 中支持向量机函数主要有两类函数：
SVC,NuSVC,LinearSVC SVR,NuSVR,LinearSVR以SVC原型说明:1
class sklearn.svm.SVC(C=1.0, kernel='rbf', degree=3, gamma='auto', coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape='ovr', random_state=None)
C：代表SVM中经验项的重要性，在正则项与经验项中权衡。C越大，越可能过拟合，C越小，越可能欠拟合。
kernel：代表使用的核函数。常用的有：linear,rbf(高斯核),poly,sigmoid,自定义函数。
class_weight：数组形式，将第i个class的类的C替换为C * class_weight[i]，提高某个类别的重要性。
sample_weight:类似class_weight,提升某个样本的重要性。class_weight与sample_weight用来解决不平衡问题。
decision_function_shape:ovr，ovo用来解决多分类问题。
ORM(Object/Relational Mapping):对象关系映射。
1 | class User{ |
这个User的实例，在数据库中至少保存name，job，age，ID四个属性。用JDBC/ODBC取出来之后，必须进行组装成一个对象，需要程序员对SQL有一定的熟悉而且还麻烦。而ORM像是在java程序和底层数据库之间架了一层，程序员只需要告诉ORM框架它的对象在数据库中是怎样储存的就可以，余下的都交给ORM框架。获得数据库中储存的数据到转化为对象只需要一步：告诉ORM框架你需要的类是什么样的（比如说查找一个ID为1的对象），之后ORM框架自动生成SQL并查找到数据拼装之后返回。
[hibernate的N+1 TODO 问题]
原子性（Atomicity）
原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚。
一致性（Consistency）
一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。
一致性是语义上的，而不是语法上的。
隔离性（Isolation）
隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。
持久性（Durability）
持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。
先介绍一下三个概念（事务的隔离级别就是针对这三个概念而设置的）
不可重复读
不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。
例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。
不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。
事务隔离的四个级别：
锁和事务隔离的关系：
人类的好朋友的回答
想要区分什么是有状态和无状态，首先要明白什么是状态。
1 | public class Person{ |
这就是一个有状态的类。
在java web中，singlton和prototype的使用
prototype（原型）每次创建都会重新创建一个实例，将construct的过程走一遍。
优缺点：
由于singlton只有一个实例，而现实情况中经常会有多线程访问的情况，如果singlton是一个有状态的实例，那么就有可能出现竞争的情况，对资源进行竞争。
prototype每次都会创建，我们知道每一次创建都需要消耗时间和资源，当有很多人访问的时候，代价又难以接受。
所以对于web中应用，如果是没有状态的类，可以实现为单例，对于有状态的类，实现为原型。
更多的讨论
在MVC架构中，struts由于与前段端交流，常会涉及到有状态的类，因此其为原型模式；而在spring中，默认为singlton（单例）模式。
在MVC的Controller，Service，Dao层中，我们应该尽可能实现为无状态的类，只包含方法。
servlet为无状态的类，session为有状态的类。
从三个方面理解RMI。
到目前为止，client端并不知道server端有那些可以调用的方法。通过设置一个中间rmiregister，server将提供的方法注册到该rmiregister中，client端可以到rmiregister中查找需要的远端调用。
远端调用实现的过程：
代码实现
在java1.8中，已经不需要使用rmic（rmi compile）手动编译stub和skeleton了所以过程会简单些。代码步骤(假设远端调用返回的对象是Warehouse)：
运行client端代码
最后client端代码：Warehouse.class,client.class
服务器端代码:Warehouse.class WarehouseImpl.class,server.class
注意：设置CLASSPATH，添加client和server的路径到CLASSPATH，否则java找不到其对应的class文件
使用jndi，配置jndi.properties
代码示例:
1 | //Warehouse 两端都有 |
[TODO activation pdf2]
执行引擎执行该类
如下图：
每个类加载器加载类的时候，首先调用它的父加载器，如果他的父加载器不能加载，再轮到它加载。
好处:首先从java的内库中加载相应的类，在加载器之间形成一种加载的优先级顺序。
1 | protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{ |
如何使用自定义的类加载器：
1 | //Book类定义 |
注意:定义ClassLoader从根本上来说就是重载findClass函数，找到需要load的类的二进制文件，在loader中处理（解密验证等等处理）之后，通过defineClass函数之后返回
invoke函数（反射）
获得反射Class类的三种反射机制：Person person = new Person();
Class clazz1 = person.getClass();Class clazz2 = person.class;Class clazz3 = Class.forName("com.cn.Person");前两个线程公用
使用mvn生成spring boot项目：
1 | mvn clean |
1 | $ ls -al /usr |
昨天一不小心将整个/usr权限改为777了，导致WiFi不能连接，sudo不能运行。也是醉了。
启动Soft update出错
主要是/usr/lib/dbus-1.0/dbus-daemon-lauch-helper权限设置出错。
改为:
1 | -rwsr-xr-- 1 root messagebus .... |
对于/usr目录下的其他软件
sudo chmod -R 755 *
有可能/var/log/cups的文件不断增大，甚至可能是到达几十G，这有可能是/usr/lib/cups/notifier/dbus权限设置不对(具体的可以看cups的error_log文件)，正确的权限是
1 | -rwxr-xr-x 1 daemon root 14328 2月 20 01:51 dbus |
修改好就可以了。
IoC(Inversion of Control)控制反转，IoC不是一种技术，本身是一种思想。想要理解IoC，首先需要理解两个词，Control(控制)和Inversion(反转)。
什么是控制？以代码为例:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16@RestController
public class BookController {
//@AutoWired
private BookService bookService;
public BookController(){
this.bookService = new BookService();
}
@ResponseBody
@RequestMapping(value = "bookIds",method = RequestMethod.GET)
public List<Book> bookIds(){
List<Book> list = bookService.fetchAll();
return list;
}
}
在这段代码中，BookController需要用到BookService，因此在前者中有一个后者的实例，换句话说，BookController可以通过这个实例控制BookService，这就是控制。而从另一个角度来说，也是BookController依赖于BookService（因为没有BookService，BookController的逻辑也不能实现）。
控制和依赖是共存的，控制也不局限于对另一个类的控制，还可以是文件，datasource等。
什么是反转？我们先考虑什么是“正转”？
注意无论是“正转”还是反转，都是相对于BookController类来说的
还是以上面的代码为例，上面的代码中，BookController是占主要的地位的类，BookService只是BookController的一部分，由BookController控制BookService，这可以理解为“正转”，因为这是占主导地位的类控制占次要地位的类(也可以理解为依赖类控制被依赖的类)，BookController主动new一个BookService的实例。
那么反转呢？反转就是在BookController和BookService中，BookController由原来的主动new一个对象，变为被动接受一个对象。就好像说，有一个第三方，在BookController需要一个BookService的时候，马上送上一个BookService。而这个第三方，就是spring容器。
依赖注入其实就是IoC的另一种说法。我们还是从两个方面来说什么是依赖注入。
什么是依赖：IoC控制的另一种说法，可以参考第一点
什么是注入：IoC容器给BookController送上一个BookService实例即可以视为注入。
AOP面向切面编程。面向对象编程的核心是对象，一切皆对象，同样的，面向切面编程，核心是切面。想要理解什么是AOP，首先需要理解切面。
什么是切面?
OOP要求我们把功能分散到单独的类中去，做到一个类做一件事。但是当许多类都分散开来的时候，也会增加类的复杂性。一个例子就是：如果所有的类都有一个打印日志的操作，要么在每个类中重复一段打印日志的代码（重复代码）；要不就是所有需要打印日志的类都依赖于一个log类（会增加所有这些类对于log类的依赖，重复逻辑）。如何才能去掉这些重复代码呢？AOP就是用来解决这个问题的，将log的方法视作一个切面，所有log操作只需要通过AOP织入即可，代码只需要写一份。
切面就是上面的log
所谓的面向切面编程，就是根据切面，在代码的适当位置（切入点）动态的插入适当的代码让其运行。
AOP:如果你有一个函数要测时间，那你就在函数开始和结束的地方各打一个时间戳，然后计算打印就行了。但如果你有一批函数，你要每个函数都这么干的话，明天老板说该上线了把debug代码都去掉怎么办，明天CTO说控制台输出太low了要改成发短信怎么办。所以你需要在一个统一的地方写这些东西。AOP就是通过配置，让符合某种条件的函数在开始和结束的时候都执行你规定的逻辑。 –摘抄自知乎
1 | Aspect(切面):从所有类中横向找出的共同逻辑 |
ExampleController类：1
2
3
4
5
6
7
8
9
10
11
12
13package com.example.demo.web;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Example {
@RequestMapping("/")
public String home() {
return "Hello World!";
}
}
Aspect类:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53package com.example.demo.Aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
@Aspect
@Component
public class WebLogAspect {
protected static org.slf4j.Logger logger = LoggerFactory.getLogger(WebLogAspect.class);
// @Pointcut("execution(public * com.example.demo..*.*(..))")
@Pointcut("execution(public * com.example.demo.web.Example.home(..))")
public void webLog() {
}
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
System.out.println( "进入doBefore切面");
// 接收到请求，记录请求内容
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// 记录下请求内容
logger.info("URL : " + request.getRequestURL().toString());
logger.info("HTTP_METHOD : " + request.getMethod());
logger.info("IP : " + request.getRemoteAddr());
logger.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
logger.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));
}
@Around("webLog()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println( "around the aspect");
Object o = joinPoint.proceed();
System.out.println( "around the aspect1");
return o;
}
@AfterReturning(returning = "ret", pointcut = "webLog()")
public void doAfterReturning(Object ret) throws Throwable {
// 处理完请求，返回内容
logger.info("RESPONSE : " + ret);
}
}
输出:1
2
3
4
5
6
7
8around the aspect
进入doBefore切面
2018-03-07 16:23:54.237 INFO 22622 --- [nio-8888-exec-1] com.example.demo.Aop.WebLogAspect : URL : http://localhost:8888/
2018-03-07 16:23:54.238 INFO 22622 --- [nio-8888-exec-1] com.example.demo.Aop.WebLogAspect : HTTP_METHOD : GET
2018-03-07 16:23:54.238 INFO 22622 --- [nio-8888-exec-1] com.example.demo.Aop.WebLogAspect : IP : 127.0.0.1
2018-03-07 16:23:54.239 INFO 22622 --- [nio-8888-exec-1] com.example.demo.Aop.WebLogAspect : CLASS_METHOD : com.example.demo.web.Example.home
2018-03-07 16:23:54.239 INFO 22622 --- [nio-8888-exec-1] com.example.demo.Aop.WebLogAspect : ARGS : []
around the aspect1
可见执行顺序是:
Around的ProceedingJoinPoint.proceed()前的方法，Before方法，被织入的方法，Around的proceed之后的方法，After执行，然后是AfterReturing方法。
除了@Around外，每个方法里都可以加或者不加参数JoinPoint，如果有用JoinPoint的地方就加，不加也可以，JoinPoint里包含了类名、被切面的方法名，参数等属性，可供读取使用。@Around参数必须为ProceedingJoinPoint，pjp.proceed相应于执行被切面的方法。@AfterReturning方法里，可以加returning = “XXX”，XXX即为在controller里方法的返回值。
当出现异常的时候，情况比较复杂，分有没有around方法讨论，因为如果有around则around当中理因处理该Exception，如果没有处理，则该exception会抛出到上一层，然后强行结束该around的advice，接着执行After方法，然后是afterthrowing方法。如果around执行了异常处理，那么afterthrow不会执行。
总结：around在before之前，after（所有类别after方法）之前执行。
afterreturing和afterthrowing在after之后执行。
[TODO poingcut的语句编写 AOP通过代理实现的原理]
详细用法参考
所有的映射均由org.springframework.data.mongodb.core.convert.MappingMongoConverter类实现。
几点基准：
@Id,@Field,id（属性名为id）均可用来指定_id。
|Field definition|Resulting Id-Fieldname in MongoDB|
|:—:|:—:|
|String id|_id|
|@Field String id|_id|
|@Field(“x”) String id|x|
|@Id String x|_id|
|@Field(“x”) @Id String x|_id|
|||
TODO 如果id不能转化为一个ObjectId怎么办？
| Type | Type conversion | Sample |
|---|---|---|
| String | native | {“firstname” : “Dave”} |
double, Double, float, Float|native|{“weight” : 42.5}|
int, Integer, short, Short|native 32-bit integer|{“height” : 42}
long, Long|native 64-bit integer|{“height” : 42}|
Date, Timestamp|native|{“date” : ISODate(“2019-11-12T23:00:00.809Z”)}|
Array, List, BasicDBList|native|{“cookies” : [ … ]}
TODO test array?
@Id - applied at the field level to mark the field used for identity purpose.
@Document - applied at the class level to indicate this class is a candidate for mapping to the database. You can specify the name of the collection where the database will be stored.
@DBRef - applied at the field to indicate it is to be stored using a com.mongodb.DBRef.
@Indexed - applied at the field level to describe how to index the field.
@CompoundIndex - applied at the type level to declare Compound Indexes
@GeoSpatialIndexed - applied at the field level to describe how to geoindex the field.
@TextIndexed - applied at the field level to mark the field to be included in the text index.
@Language - applied at the field level to set the language override property for text index.
@Transient - by default all private fields are mapped to the document, this annotation excludes the field where it is applied from being stored in the database
@PersistenceConstructor - marks a given constructor - even a package protected one - to use when instantiating the object from the database. Constructor arguments are mapped by name to the key values in the retrieved Document.
@Value - this annotation is part of the Spring Framework . Within the mapping framework it can be applied to constructor arguments. This lets you use a Spring Expression Language statement to transform a key’s value retrieved in the database before it is used to construct a domain object. In order to reference a property of a given document one has to use expressions like: @Value("#root.myProperty") where root refers to the root of the given document.
@Field - applied at the field level and described the name of the field as it will be represented in the MongoDB BSON document thus allowing the name to be different than the fieldname of the class.
@Version - applied at field level is used for optimistic locking and checked for modification on save operations. The initial value is zero which is bumped automatically on every update.
记录的版本，示例
@TypeAlias("pers")在mongodb中该类的_class为pers。@PersistenceConstructor标记一个构造器，指定用来构造类的实例，并可以结合@Value使用，可以达到修改构造器用处。1
2
3
4
5
6
7
8
9
10
11
12
13
14@Document
static class ObjectContainer {
@Field("property") private final PrimitiveContainer m_property;
@PersistenceConstructor
public ObjectContainer(@Value("#root.property") PrimitiveContainer a_property) {
m_property = a_property;
}
public PrimitiveContainer property() {
return m_property;
}
}
最常用的两个操作Mongodb的类是MongoTemple，Repository类。
使用MongoClient1
2
3public MongoClient mongoClient() {
return new MongoClient();
}
常用的MongoClient类构造方法：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public MongoClient(String host) {
this(new ServerAddress(host));
}
public MongoClient(String host, int port) {
this(new ServerAddress(host, port));
}
public MongoClient(ServerAddress addr) {
this(addr, (new Builder()).build());
}
public MongoClient(MongoClientURI uri) {
super(uri);
}
MongoClientFactoryBean对应MongoClient的工厂模式，可以用来构建MongoClient（createInstance方法）。
MongoTemple的三种构造方法
MongoTemplate(MongoClient mongo, String databaseName) - takes the com.mongodb.MongoClient object and the default database name to operate against.
MongoTemplate(MongoDbFactory mongoDbFactory) - takes a MongoDbFactory object that encapsulated the com.mongodb.MongoClient object, database name, and username and password.
MongoTemplate(MongoDbFactory mongoDbFactory, MongoConverter mongoConverter) - adds a MongoConverter to use for mapping.
MongoTemple的CRUD：
插入数据:1
2
3
4
5
6
7
8
9void save (Object objectToSave) Save the object to the default collection.
void save (Object objectToSave, String collectionName) Save the object to the specified collection.
A similar set of insert operations is listed below
void insert (Object objectToSave) Insert the object to the default collection.
void insert (Object objectToSave, String collectionName) Insert the object to the specified collection.
区别:
insert在出现相同的id的时候，会出现错误，而save会覆盖原值。(只限于id)
1 | insertAll(Collection objectionsToSave) |
Update:1
2
3updateFirst Updates the first document that matches the query document criteria with the provided updated document.
updateMulti Updates all objects that match the query document criteria with the provided updated document.
常见的update方法的示例1
2WriteResult wr = mongoTemplate.updateMulti(new Query(where("accounts.accountType").is(Account.Type.SAVINGS)),
new Update().inc("accounts.$.balance", 50.00), Account.class);
Update的方法(和mongodb中的原生update方法类似)：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18[TODO to review]
Update addToSet (String key, Object value) Update using the $addToSet update modifier
Update currentDate (String key) Update using the $currentDate update modifier
Update currentTimestamp (String key) Update using the $currentDate update modifier with $type timestamp
Update inc (String key, Number inc) Update using the $inc update modifier
Update max (String key, Object max) Update using the $max update modifier
Update min (String key, Object min) Update using the $min update modifier
Update multiply (String key, Number multiplier) Update using the $mul update modifier
Update pop (String key, Update.Position pos) Update using the $pop update modifier
Update pull (String key, Object value) Update using the $pull update modifier
Update pullAll (String key, Object[] values) Update using the $pullAll update modifier
Update push (String key, Object value) Update using the $push update modifier
Update pushAll (String key, Object[] values) Update using the $pushAll update modifier
Update rename (String oldName, String newName) Update using the $rename update modifier
Update set (String key, Object value) Update using the $set update modifier
Update setOnInsert (String key, Object value) Update using the $setOnInsert update modifier
Update unset (String key) Update using the $unset update modifier
删除数据1
2
3
4
5
6
7
8
9
10
11template.remove(tywin, "GOT"); <1>
template.remove(query(where("lastname").is("lannister")), "GOT"); <2>
template.remove(new Query().limit(3), "GOT"); <3>
template.findAllAndRemove(query(where("lastname").is("lannister"), "GOT");<4>
template.findAllAndRemove(new Query().limit(3), "GOT"); <5>
Remove a single entity via its _id from the associated collection.
Remove all documents matching the criteria of the query from the GOT collection.
Remove the first 3 documents in the GOT collection. Unlike <2>, the documents to remove are identified via their _id executing the given query applying sort, limit and skip options first and then remove all at once in a separate step.
Remove all documents matching the criteria of the query from the GOT collection. Unlike <3>, documents do not get deleted in a batch but one by one.
Remove the first 3 documents in the GOT collection. Unlike <3>, documents do not get deleted in a batch but one by one.
区别:
remove当有多个需要删除的记录时，一次删除；而findAllAndRemove则是一跳一条记录删除。
Upsert数据
如果数据库中没有该记录则插入数据库中：1
template.upsert(query(where("ssn").is(1111).and("firstName").is("Joe").and("Fraizer").is("Update")), update("address", addr), Person.class);
查找并修改数据：返回原值
1 | <T> T findAndModify(Query query, Update update, Class<T> entityClass); |
如果想返回新值：1
p = template.findAndModify(query, update, new FindAndModifyOptions().returnNew(true), Person.class);
The FindAndModifyOptions lets you set the options of returnNew, upsert, and remove.
查找数据：[TODO review]
BasicQuery用于直接处理mongo的查找语句。
1 | BasicQuery query = new BasicQuery("{ age : { $lt : 50 }, accounts.balance : { $gt : 1000.00 }}"); |
标准面向对象的Query方法：
1 | Criteria all (Object o) Creates a criterion using the $all operator |
1 | List<Person> result = mongoTemplate.find(query(where("age").lt(50) |
其他find的方法：
1 | `findAll` Query for a list of objects of type T from the collection. |
TextQuery
1 | TextQuery.searching(new TextCriteria().matching("coffee").matching("-cake")); |
Query by Example（QBE）
TODO
Repositories只是作为一个Spring-data的一个标示，同时也是其的一个核心借口，内部不存在方法，所有的方法都是通过Spring的内部注入机制注入。
在Repositories上层是CrudRepository。CrudRepository借口定义了几个基本的方法。spring-data同时提供JpaRepository,MongoRepository接口，屏蔽了底层实现逻辑。
在CrudRepository上层是PagingAndSortingRepository，该接口定义了分页查询等接口。