最近折腾了个自建的 nas，为了使用 jellyfin 这样的影视应用需要对视频进行刮削，对于电视剧来说还是有些不一样的，
比如我要刮削这部经典电视剧纪晓岚
像这样的命名方式在 tmm 中是无法识别的，或者就得一集一集进行制定刮削，
所以第一步需要进行改名
比如这是第一季的，那就是 S01，然后按集数 E01，第一季第一集的文件名就是 S01E01.mkv
然后右键点击搜索刮削，默认会以文件夹名进行搜索，是在 tmdb 数据库进行搜索
这样除非文件夹名很符合要求，一般都刮削不出来，所以需要有两种刮削方式，一种就是比较标准的命名，这样的名字可以手动先去豆瓣或者 tmdb 搜索，另一个种也可以在豆瓣找到 imdb 的 id 进行搜索
但有时候也会搜不到，比如这个纪晓岚就是搜不到，但是之前的一些韩剧什么的很多都能搜到
这个其实是最基本的刮削，但是这样刮削了需要在 jellyfin 那取消元数据下载
，这样就不会被覆盖
这个可能是个很简单的点，不过之前碰到了就记录下，我们常规的应用都是使用统一的请求响应转换器去处理请求和响应返回，但是对于有文件上传或者返回的是文件的情况，一般都是不使用统一的处理，但是在响应返回的时候可能会存在这样的情况，如果文件正常被处理那就返回文件，如果处理异常需要给前端返回 json类型的响应，里面能够取到响应码错误描述等
比如在请求中参数就使用 httpRequest(HttpServletRequest request, HttpServletResponse response)
然后在返回的时候就使用 response.getOutputStream().write(result)，而如果是要返回 json 形式的话就可以像这个文章说明的
链接1
2
3
4
5
6
7
8Employee employee = new Employee(1, "Karan", "IT", 5000);
String employeeJsonString = this.gson.toJson(employee);
PrintWriter out = response.getWriter();
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
out.print(employeeJsonString);
out.flush();
一开始我也是这么一搜就用了，后来发现返回的一直是乱码，仔细看了下发现了个问题，就是这个 response 设置 contentType 是在getWriter之后的，这样自然就不会起作用了，所以要在设置 setContentType 和 setCharacterEncoding 之后再 getWriter，之后就可以正常返回了。
最近在搞 nas 的时候又翻了个很大的错误，因为前面说了正在用的技嘉的 z370m, 这个主板是跟 cpu 一起买的，如果是只是用在 Windows 环境，没什么扩展要求，或者只用 6 个sata盘位，用一个 ssd 做系统盘，是挺不错的，但是如果是像我这样的要搞盘位比较多的nas，发现有一系列的不足点，
1、 前面有讲过，网卡问题，用的是 RTL 瑞昱的网卡，目前知道的最高能支持的 exsi 的版本是 6.7，再高的版本就不支持了，不过其实真的想用的话，6.7 版本也是可以用的，只是我当时是打包的 8.0 的系统，个人也不太喜欢用比较低版本的，所以算是一个不足点
2、 第二点是m.2插槽，只有一个m.2也是很难理解的，一个做系统盘，另一个可以作为简单的数组存储，或者作为群晖的下载缓存，如果只有一个的话特别是现在这个 ssd 的价格这么低了，加一个还是很香的，这个问题跟后面也是有点关系的
3、 PCIE 的插槽，这个主板只支持两个 PCIE 3.0 x1 的，它能支持 1Gbps 的传输速度，后面我买了个 PCIE 3.0 x1 转 m.2 的转接卡，这样其实真的是把速度拖慢了很多，还有一个 PCIE 3.0 X16 的，这是用来装显卡的，只用来扩展做个m.2或者 sata 又感觉很浪费，而且说不定未来会装个显卡
4、 风扇口的问题，风扇接口其实原来一直没概念，我在这次装 nas 之前其实自己没有完整装个台式机过，之前买的目前在使用的主力机两个风扇在换了的时候才知道是用的大 4pin 接口串接的，其中一个有 pwm 的接口也没用，这样就没办法用主板自带调速软件来进行自动或者手动调速，有时候比如晚上不关机，放在房间里风扇声很大还是挺吵的，这个主板只有两个风扇接口，一个是 cpu 的，一个是系统风扇，其实就只有一个可以用了
主要是以上几个点，所以我一直在关注二手主板，之前买了个华硕的 z370 tuf gaming，没想到点不亮，也不知道什么原因，还害我吓得以为 cpu 被我弄坏了，后面慢慢在网上看着发现有一块微星的 z390 TOMAHAWK战斧导弹，各方面接口都很不错，而且还有个千兆网口，在闲鱼蹲了很久终于在前不久蹲到了，买回来赶紧看看能不能点亮，结果一把点亮，还是用的螺丝刀开机的，就心里暗爽感觉捡到了宝，但是装进我的半岛铁盒 F10 机箱就发现跪了，出现的这个问题原来在网上哪里看到过，一直没注意，就是 sata 接口的方向，因为一个是 matx 的板，装进去即使 sata 接口的方向是跟主板平行的也留着足够的空间，但是 atx 板装上之后，大概只有 2 厘米左右的空间并且是两个叠着的端口，一个可能要能硬拗一下，但是两个我试了下，只能识别出一个，这个真让我翻了个大车，而且其实我换这个主板其实还有个大问题，就是我是在 Windows 下的vmware workstation 虚拟机里通过sata 直通，但是这个是认硬盘接口的，也就是顺序是有影响的，换了主板发现也不能支持，后面可能真的想用的话还得重新搞黑裙，要把数据备份出来，幸好换回原来的主板还能用，所以硬件也不能只看性能和接口丰富度，要看适配的其他硬件的合适度以及原先已经有的软件系统
在 org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration 中进行配置解析，其中这一行就是解析 mappers1
mapperElement(root.evalNode("mappers"));
具体的代码会执行到这1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) {
// 这里解析的不是 package
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else {
// 根据 resource 和 url 还有 mapperClass 判断
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
// resource 不为空其他为空的情况，就开始将 resource 读成输入流
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
// 初始化 XMLMapperBuilder 来解析 mapper
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();
}
然后再是 parse 过程1
2
3
4
5
6
7
8
9
10
11
12public void parse() {
if (!configuration.isResourceLoaded(resource)) {
// 解析 mapper 节点，也就是下图中的mapper
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
继续往下走1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.isEmpty()) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
// 处理cache 和 cache 应用
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
resultMapElements(context.evalNodes("/mapper/resultMap"));
sqlElement(context.evalNodes("/mapper/sql"));
// 因为我们是个 sql 查询，所以具体逻辑是在这里面
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
}
}
然后是1
2
3
4
5
6
7private void buildStatementFromContext(List<XNode> list) {
if (configuration.getDatabaseId() != null) {
buildStatementFromContext(list, configuration.getDatabaseId());
}
// 然后没有 databaseId 就走到这
buildStatementFromContext(list, null);
}
继续1
2
3
4
5
6
7
8
9
10
11
12private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
// 创建语句解析器
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
// 解析节点
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
这个代码比较长，做下简略，只保留相关代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21public void parseStatementNode() {
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
String nodeName = context.getNode().getNodeName();
SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
// 简略前后代码，主要看这里，创建 sqlSource
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
然后根据 LanguageDriver，我们这用的 XMLLanguageDriver，先是初始化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
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
return builder.parseScriptNode();
}
// 初始化有一些逻辑
public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
super(configuration);
this.context = context;
this.parameterType = parameterType;
// 特别是这，我这次特意在 mapper 中加了 foreach，就是为了说下这一块的解析
initNodeHandlerMap();
}
// 设置各种类型的处理器
private void initNodeHandlerMap() {
nodeHandlerMap.put("trim", new TrimHandler());
nodeHandlerMap.put("where", new WhereHandler());
nodeHandlerMap.put("set", new SetHandler());
nodeHandlerMap.put("foreach", new ForEachHandler());
nodeHandlerMap.put("if", new IfHandler());
nodeHandlerMap.put("choose", new ChooseHandler());
nodeHandlerMap.put("when", new IfHandler());
nodeHandlerMap.put("otherwise", new OtherwiseHandler());
nodeHandlerMap.put("bind", new BindHandler());
}
初始化解析器以后就开始解析了1
2
3
4
5
6
7
8
9
10
11public SqlSource parseScriptNode() {
// 先是解析 parseDynamicTags
MixedSqlNode rootSqlNode = parseDynamicTags(context);
SqlSource sqlSource;
if (isDynamic) {
sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
} else {
sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
}
return sqlSource;
}
但是这里可能做的事情比较多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
33protected MixedSqlNode parseDynamicTags(XNode node) {
List<SqlNode> contents = new ArrayList<>();
// 获取子节点，这里可以把我 xml 中的 SELECT 语句分成三部分，第一部分是 select 到 in，然后是 foreach 部分，最后是\n结束符
NodeList children = node.getNode().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
XNode child = node.newXNode(children.item(i));
// 第一个节点是个纯 text 节点就会走到这
if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
String data = child.getStringBody("");
TextSqlNode textSqlNode = new TextSqlNode(data);
if (textSqlNode.isDynamic()) {
contents.add(textSqlNode);
isDynamic = true;
} else {
// 在 content 中添加这个 node
contents.add(new StaticTextSqlNode(data));
}
} else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
// 第二个节点是个带 foreach 的，是个内部元素节点
String nodeName = child.getNode().getNodeName();
// 通过 nodeName 获取处理器
NodeHandler handler = nodeHandlerMap.get(nodeName);
if (handler == null) {
throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
}
// 调用处理器来处理
handler.handleNode(child, contents);
isDynamic = true;
}
}
// 然后返回这个混合 sql 节点
return new MixedSqlNode(contents);
}
再看下 handleNode 的逻辑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
public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
// 又会套娃执行这里的 parseDynamicTags
MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
String collection = nodeToHandle.getStringAttribute("collection");
Boolean nullable = nodeToHandle.getBooleanAttribute("nullable");
String item = nodeToHandle.getStringAttribute("item");
String index = nodeToHandle.getStringAttribute("index");
String open = nodeToHandle.getStringAttribute("open");
String close = nodeToHandle.getStringAttribute("close");
String separator = nodeToHandle.getStringAttribute("separator");
ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, nullable, index, item, open, close, separator);
targetContents.add(forEachSqlNode);
}
// 这里走的逻辑不一样了
protected MixedSqlNode parseDynamicTags(XNode node) {
List<SqlNode> contents = new ArrayList<>();
// 这里是 foreach 内部的，所以是个 text_node
NodeList children = node.getNode().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
XNode child = node.newXNode(children.item(i));
// 第一个节点是个纯 text 节点就会走到这
if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
String data = child.getStringBody("");
TextSqlNode textSqlNode = new TextSqlNode(data);
// 判断是否动态是根据代码里是否有 ${}
if (textSqlNode.isDynamic()) {
contents.add(textSqlNode);
isDynamic = true;
} else {
// 所以还是会走到这
// 在 content 中添加这个 node
contents.add(new StaticTextSqlNode(data));
}
// 最后继续包装成 MixedSqlNode
// 再回到这里
public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
// 处理 foreach 内部的各个变量
String collection = nodeToHandle.getStringAttribute("collection");
Boolean nullable = nodeToHandle.getBooleanAttribute("nullable");
String item = nodeToHandle.getStringAttribute("item");
String index = nodeToHandle.getStringAttribute("index");
String open = nodeToHandle.getStringAttribute("open");
String close = nodeToHandle.getStringAttribute("close");
String separator = nodeToHandle.getStringAttribute("separator");
ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, nullable, index, item, open, close, separator);
targetContents.add(forEachSqlNode);
}
再回过来1
2
3
4
5
6
7
8
9
10
11
12public SqlSource parseScriptNode() {
MixedSqlNode rootSqlNode = parseDynamicTags(context);
SqlSource sqlSource;
// 因为在 foreach 节点处理时直接是把 isDynamic 置成了 true
if (isDynamic) {
// 所以是个 DynamicSqlSource
sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
} else {
sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
}
return sqlSource;
}
这里就做完了预处理工作，真正在执行的执行的时候还需要进一步解析
因为前面讲过很多了，所以直接跳到这里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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
public <T> T selectOne(String statement, Object parameter) {
// Popular vote was to return null on 0 results and throw exception on too many.
// 都知道是在这进去
List<T> list = this.selectList(statement, parameter);
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
}
public <E> List<E> selectList(String statement, Object parameter) {
return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
}
private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
try {
// 前面也讲过这个，
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
// 包括这里，是调用的org.apache.ibatis.executor.CachingExecutor#query(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
// 然后是获取 BoundSql
public BoundSql getBoundSql(Object parameterObject) {
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings == null || parameterMappings.isEmpty()) {
boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
}
// check for nested result maps in parameter mappings (issue #30)
for (ParameterMapping pm : boundSql.getParameterMappings()) {
String rmId = pm.getResultMapId();
if (rmId != null) {
ResultMap rm = configuration.getResultMap(rmId);
if (rm != null) {
hasNestedResultMaps |= rm.hasNestedResultMaps();
}
}
}
return boundSql;
}
// 因为前面讲了是生成的 DynamicSqlSource，所以也是调用这个的 getBoundSql
public BoundSql getBoundSql(Object parameterObject) {
DynamicContext context = new DynamicContext(configuration, parameterObject);
// 重点关注着
rootSqlNode.apply(context);
SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
context.getBindings().forEach(boundSql::setAdditionalParameter);
return boundSql;
}
// 继续是这个 DynamicSqlNode 的 apply
public boolean apply(DynamicContext context) {
contents.forEach(node -> node.apply(context));
return true;
}
// 看下面的图
我们重点看 foreach 的逻辑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
53
54
55
56
57
58
public boolean apply(DynamicContext context) {
Map<String, Object> bindings = context.getBindings();
final Iterable<?> iterable = evaluator.evaluateIterable(collectionExpression, bindings,
Optional.ofNullable(nullable).orElseGet(configuration::isNullableOnForEach));
if (iterable == null || !iterable.iterator().hasNext()) {
return true;
}
boolean first = true;
// 开始符号
applyOpen(context);
int i = 0;
for (Object o : iterable) {
DynamicContext oldContext = context;
if (first || separator == null) {
context = new PrefixedContext(context, "");
} else {
context = new PrefixedContext(context, separator);
}
int uniqueNumber = context.getUniqueNumber();
// Issue #709
if (o instanceof Map.Entry) {
Map.Entry<Object, Object> mapEntry = (Map.Entry<Object, Object>) o;
applyIndex(context, mapEntry.getKey(), uniqueNumber);
applyItem(context, mapEntry.getValue(), uniqueNumber);
} else {
applyIndex(context, i, uniqueNumber);
applyItem(context, o, uniqueNumber);
}
// 转换变量名，变成这种形式 select * from student where id in
// (
// #{__frch_id_0}
// )
contents.apply(new FilteredDynamicContext(configuration, context, index, item, uniqueNumber));
if (first) {
first = !((PrefixedContext) context).isPrefixApplied();
}
context = oldContext;
i++;
}
applyClose(context);
context.getBindings().remove(item);
context.getBindings().remove(index);
return true;
}
// 回到外层就会调用 parse 方法， 把#{} 这段替换成 ?
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
String sql;
if (configuration.isShrinkWhitespacesInSql()) {
sql = parser.parse(removeExtraWhitespaces(originalSql));
} else {
sql = parser.parse(originalSql);
}
return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}
可以看到这里，然后再进行替换
真实的从 ? 替换成具体的变量值，是在这里org.apache.ibatis.executor.SimpleExecutor#doQuery
调用了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
47private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
public void parameterize(Statement statement) throws SQLException {
parameterHandler.setParameters((PreparedStatement) statement);
}
public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
// -------------------------->
// 替换变量
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException | SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}
上次说 nas 的方案我是在 win10 下使用vmware workstation 搭建的黑裙虚拟机，采用 sata 物理磁盘直通的方式，算是跑通了黑裙的基础使用模式，但是后来发现的一个问题是之前没考虑到的，我买了不带 f 的处理器就是为了核显能做硬解，但是因为 cpu 是通过 vmware 虚拟的，目前看来是没法直通核显的，我是使用的 jellyfin 套件，一开始使用是默认的刮削方式，而且把电视剧当成了电影在刮削，所以基本不能看，后面使用了 tmm 作为刮削工具，可以手动填写 imdb 的id 来进行搜索，一般比较正式的剧都可以在豆瓣上找到的，然后让 jellyfin 只作为媒体管理器，但是前面的问题还是没解决，所以考虑了下可以在win10 下直接运行 jellyfin，媒体目录使用挂载在 nas 里的盘，这样 jellyfin 就能直接调用核显了，也算是把 win10 本身给利用起来了，并且文件的管理还是在黑裙中。
现在想来其实我这个方案还是不太合理，cpu 性能有点过剩想通过虚拟机的形式进行隔离使用，但是购买带核显的 cpu 最大的目的却没有实现，如果是直接裸机部署黑裙的话，真的是觉得 cpu 有点太浪费了，毕竟 passmark评分有 1w3 的cpu，只用来跑黑裙，所以网上的很多建议也是合理的，不过我可能是 win10 用的比较多了，还是习惯有 win 的环境。