-
2020-11-30 02:01:34
简单提供几个思路。
比较常见的做法是通过训练词向量,计算词向量的相似度。正如题主所说的word2vec就是最常见的是训练词向量的方法。
word2vec是Google的一个开源工具,通过将词转化成向量的形式,可以把对文本內容的处理简化为向量空间中的向量运算,往往会结合余弦相似度来计算向量空间上的相似度,來表示文本语意上的相似度。
例如:
word2vec训练词向量的方法是通过上下文去预测某个词或者通过一个词去预测上下文,所以除了得到语义相近的词,往往还会得到搭配比较多的关联词。所以word2vec是可行的。同理,其他训练词向量的方法也是可以的,比如glove或者fasttext等。而对于计算相似度的方法就更多了,就不概述了。
还有通过句子结构分析和词与词之间的事理关系也是可以得到一些关联词,比如存在“不仅A而且B”这种句式时,A和B是很有可能是关联词,甚至是近义词。除了并列,还有顺承,转折等关系也是可以寻找关联词的。
只从词本身看,有时候研究词与词的共现关系或者根据相同上下文相邻词的频数也可以挖掘关联词。
更多相关内容 -
一种融合词项关联关系和统计信息的短文本建模方法
2021-02-22 09:10:38为了解决传统文本表示方法词袋模型对文本语义的忽略问题,提出一种融合词项关联关系和统计信息的短文本建模方法。通过词语之间的内联及外联关系耦合得到词语关联关系,充分挖掘了显示和隐含的语义信息;同时以关联关系... -
融合词项关联关系的半监督微博聚类算法
2021-03-16 12:06:17该算法利用词项间的关系丰富文本特征,通过定义词项文档间关联关系和词项文档内关联关系揭示词项间语义的关联程度,并由此自动生成有标记的数据来指导聚类过程。对词项先验信息进行成对约束编码,构建基于词项间成对... -
基于词项关联关系与归一化割加权的微博用户兴趣模型
2021-02-09 13:56:25提出一种基于词项关联关系与归一化割加权非负矩阵分解的微博用户兴趣模型构建方法。该方法首先基于词分布上下文语义相关性来建立词项关联关系矩阵刻画词项间相似度,然后应用归一化割加权非负矩阵分解算法获取用户—... -
基于关联词对动态抽取的报道关系检测技术研究 (2010年)
2021-05-22 04:23:16提出了一种基于关联词对动态抽取的报道关系检测方法。关联词对是指在同一篇报道中出现的满足一定关系约束的两个单词,而关系约束是指一组特征的集合。该方法认为两篇报道中出现的相同的关联词对越多,两篇报道的... -
基于要素提取关联词对的中文报道关系检测 (2013年)
2021-05-21 01:46:46在多向量空间模型基础上提取不同向量的要素(时间、地点、人物和内容)特征词组成关联词对,使用支持向量机(SVM)方法整合关联词对相似度和余弦相似度,从而提出了一种提取要素关联词对报道关系检测方法。所提方法补充... -
论文研究-基于词项关联关系与归一化割加权的微博用户兴趣模型.pdf
2019-07-22 19:26:20提出一种基于词项关联关系与归一化割加权非负矩阵分解的微博用户兴趣模型构建方法。该方法首先基于词分布上下文语义相关性来建立词项关联关系矩阵刻画词项间相似度,然后应用归一化割加权非负矩阵分解算法获取用户—... -
「写论文」“常用关联词”汇总
2019-05-28 18:12:48写论文、报告、项目书时,为了增强文章的结构性和行文的通顺性,应多使用关联词。小白把一些常用的关联词列举在下面,方便写文章时拿出来翻阅。 关联词共分成8类: 转折关系、假设关系、并列关系、递进关系、选择...写论文、报告、项目书时,为了增强文章的结构性和行文的通顺性,应多使用关联词。小白把一些常用的关联词列举在下面,方便写文章时拿出来翻阅。
关联词共分成8类:
转折关系、假设关系、并列关系、递进关系、选择关系、因果关系、条件关系、承接关系。
1.转折关系
- 虽然……但是……
- 尽管……还是……
- …… 却……
- ……然而……
- ……但是……
- 虽然... ...却
- 既然......也......
2.假设关系
- 如果……就……
- 要是……那么......
- 即便…...也……
- 即使……也……
- 倘若……就……
- 要是……就……
- 倘若.......便......
3.并列关系
- 一边……一边……
- 一会儿…… 一会儿……
- 既……又……
- 又... ...又... ...
- 一面.......一面...
- 有……有……
4.递进关系
- 不但……而且……
- 不光……也……
- 不仅……还…
- 不但不……反而……
5.选择关系
- 是……还是……
- 要么……要么……
- 或者......或者......
- 与其……不如……
- 宁可(宁愿)……也不(决不)……
6.因果关系
- 因为……所以……
- 之所以……是因为……
- 由于……因此……
7.条件关系
- 只要……就……
- 只有……才……
- 无论 (不论、不管、任凭)……都(也、还) 。
- ……却……
- ……是……是……
8.承接关系
- 一……就……
- 首先……然后……
- ……于是……
- ……才……
- ……接着……
-
词网络的新闻事件关联建模* (2014年)
2021-05-14 17:03:20该方法首先利用TF-IEF和相邻词合并策略对事件的相关报道集提取关键词,然后综合多种词共现度量窗口对事件关键词的关联关系建模,构建事件关键词关联网络,最后依据事件间共有关键词的程度建立事件关联模型,从而建立... -
论文研究-基于特征词关联性的同义词集挖掘算法.pdf
2019-07-22 23:07:34深入分析了概念、词汇和特征词三者的内在关系,并在此基础上提出了一种基于同义词汇的特征词的关联性,从文本中挖掘同义词集的算法。根据特征词之间存在关联性的特点,算法以成熟的关联规则挖掘算法作为基础,获得了... -
离散数学-各种关联词的符号化
2017-02-28 23:14:00离散数学--关联词的符号化问题 ①如果p那么q p->q; ②只有p才q q->p;(p是q的必要条件) 仔细想一下,只有p->q和q->p两种情况,p成立不一定q成立,而q成立,那么p就一定成立,所以后者正确; ③只要p就q ...离散数学--关联词的符号化问题
①如果p那么q p->q;
②只有p才q q->p;(p是q的必要条件)
仔细想一下,只有p->q和q->p两种情况,p成立不一定q成立,而q成立,那么p就一定成立,所以后者正确;
③只要p就q p->q;(p是q的充分条件) 同①
④仅当p, q q->p(仅当不就是只有吗?)
⑤当且仅当p,q q<->p(充要条件,与==等价)
⑥除非p 否则 q 非q->p
(例:除非世界末日,否则我活着 》》 我死 -> 世界末日)
只要 就-------充分条件
只有 才-------必要条件
暂时没有例子
-
mybatis关联(一对一、一对多、多对多)
2020-06-20 22:46:13iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)。 MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层...转载:https://www.cnblogs.com/tianlifitting/p/8583231.html
1、什么是MyBatis?,
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)。
MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射,将接口和 Java 的POJOs(Plain Ordinary Java Objects,普通的 Java对象)映射成数据库中的记录。
2、MyBatis 入门实例基于xml配置
①、创建MySQL数据库:mybatisDemo和表:person
1
2
3
create database mybatisDemo;
use mybatisDemo;
create table person(pid
int
primary key AUTO_INCREMENT, pname varchar(
50
), page
int
);
②、建立一个Java工程,并导入相应的jar包
相应的 jar 包下载链接:百度网盘-链接不存在 密码:nkt6
③、在 MyBatisDemo 工程中添加数据库配置文件 mybatis-configuration.xml,这一步按照自己项目框架结构进行自由配置!
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
<?xml version=
"1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE configuration PUBLIC
"-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd"
>
<configuration>
<!-- 可以配置多个运行环境,但是每个 SqlSessionFactory 实例只能选择一个运行环境
一、development:开发模式
二、work:工作模式-->
<environments
default
=
"development"
>
<!--id属性必须和上面的
default
一样 -->
<environment id=
"development"
>
<!--事务管理器
一、JDBC:这个配置直接简单使用了 JDBC 的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围
二、MANAGED:这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让容器来管理事务的整个生命周期
比如 spring 或 JEE 应用服务器的上下文,默认情况下,它会关闭连接。然而一些容器并不希望这样,
因此如果你需要从连接中停止它,就可以将 closeConnection 属性设置为
false
,比如:
<transactionManager type=
"MANAGED"
>
<property name=
"closeConnection"
value=
"false"
/>
</transactionManager>
-->
<transactionManager type=
"JDBC"
/>
<!--dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象源 -->
<dataSource type=
"POOLED"
>
<property name=
"driver"
value=
"com.mysql.jdbc.Driver"
/>
<property name=
"url"
value=
"jdbc:mysql://localhost:3306/mybatisdemo"
/>
<property name=
"username"
value=
"root"
/>
<property name=
"password"
value=
"root"
/>
</dataSource>
</environment>
</environments>
</configuration>
④、定义表所对应的实体类
⑤、定义操作 person 表的sql映射文件personMapper.xml
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
<?xml version=
"1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
>
<mapper namespace=
"com.ys.bean.personMapper"
>
<!-- 根据 pid 查询 person 表中的数据
id:唯一标识符,此文件中的id值不能重复
resultType:返回值类型,一条数据库记录也就对应实体类的一个对象
parameterType:参数类型,也就是查询条件的类型
-->
<select id=
"selectPersonById"
resultType=
"com.ys.bean.Person"
parameterType=
"int"
>
<!-- 这里和普通的sql 查询语句差不多,对于只有一个查询条件后面的 #{pid}表示占位符,里面不一定要写pid,写啥都可以,但是不要空着;如果有多个查询条件,则要写pojo类里面的属性 -->
select * from person where pid = #{pid}
</select>
<!-- 查询person 表所有数据 -->
<select id=
"getAllPerson"
resultType=
"com.ys.bean.Person"
>
select * from person
</select>
<!-- 根据id更新数据 -->
<update id=
"updatePersonById"
parameterType=
"com.ys.bean.Person"
>
update person set pname=#{pname},page=#{page} where pid = #{pid}
</update>
<!-- 向 person 表插入一条数据 -->
<insert id=
"addPerson"
parameterType=
"com.ys.bean.Person"
>
insert into person(pid,pname,page) values(#{pid},#{pname},#{page})
</insert>
<!-- 根据 pid 删除数据 -->
<delete id=
"deletePersonById"
parameterType=
"Long"
>
delete from person where pid=#{pid}
</delete>
</mapper>
⑥、向 mybatis-configuration.xml 配置文件中注册 personMapper.xml 文件
1
2
3
4
5
<mappers>
<!-- 注册personMapper.xml文件,
personMapper.xml位于com.ys.bean这个包下,所以resource写成com/ys/bean/personMapper.xml-->
<mapper resource=
"com/ys/bean/personMapper.xml"
/>
</mappers>
如下图所示:
⑦、创建测试类
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
81
82
83
84
85
86
87
88
package
com.ys.test;
import
java.io.InputStream;
import
java.util.List;
import
org.apache.ibatis.session.SqlSession;
import
org.apache.ibatis.session.SqlSessionFactory;
import
org.apache.ibatis.session.SqlSessionFactoryBuilder;
import
org.junit.Before;
import
org.junit.Test;
import
com.ys.bean.Person;
public
class
MyBatisTest {
SqlSession session;
@Before
public
void
beforeLoadXML(){
//加载 mybatis 配置文件
InputStream inputStream = MyBatisTest.
class
.
getClassLoader().getResourceAsStream(
"mybatis-configuration.xml"
);
//构建sqlSession的工厂
SqlSessionFactory sqlSessionFactory =
new
SqlSessionFactoryBuilder().build(inputStream);
//根据 sqlSessionFactory 产生 session
session = sqlSessionFactory.openSession();
}
//根据 pid 查询 person 表中的数据
@Test
public
void
testSelectById(){
//这个字符串有 personMapper.xml 文件中 两个部分构成
//<mapper namespace="com.ys.bean.personMapper"> 的 namespace 的值
//<select id="selectPersonById" > id 值
String statement =
"com.ys.bean.personMapper"
+
".selectPersonById"
;
Person p = session.selectOne(statement,
1
);
System.out.println(p);
session.close();
}
//查询person 表所有数据
@Test
public
void
testGetAllPerson(){
String statement =
"com.ys.bean.personMapper.getAllPerson"
;
List<Person> listPerson = session.selectList(statement);
System.out.println(listPerson);
session.close();
}
//根据id更新数据
@Test
public
void
updateById(){
String statement =
"com.ys.bean.personMapper.updatePersonById"
;
Person p =
new
Person();
p.setPid(
1
);
p.setPname(
"aaa"
);
p.setPage(
11
);
session.update(statement, p);
session.commit();
session.close();
}
//向 person 表插入一条数据
@Test
public
void
addPerson(){
String statement =
"com.ys.bean.personMapper.addPerson"
;
Person p =
new
Person();
//由于我们设置了主键的自增长机制,故这里不需要手动设置 pid 的值
//p.setPid(1);
p.setPname(
"add"
);
p.setPage(
11
);
session.insert(statement, p);
session.commit();
session.close();
}
//根据 pid 删除person 表中的数据
@Test
public
void
deletePersonById(){
String statement =
"com.ys.bean.personMapper.deletePersonById"
;
session.delete(statement,
1
);
session.commit();
session.close();
}
}
4、MyBatis 入门实例 一对一 基于xml配置
这里我们以老师和班级为例,假设一般班级只能拥有有一个老师,一个老师只能带一个班级。
①、创建实体类
Teacher.java和Classes.java
②、在数据库中根据实体类创建相应的数据表
③、定义操作 Classes 表的sql映射文件classesMapper.xml
<?xml version="1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
>
<mapper namespace=
"one.to.one.classesMapper"
>
<!--
方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集
封装联表查询的数据(去除重复的数据)
select * from classes c, teacher t where c.tid=t.tid and c.tid=#{tid}
-->
<select id=
"getClasses"
resultMap=
"getClassesMap"
parameterType=
"int"
>
select * from classes c ,teacher t
where c.tid=t.tid and c.tid=#{tid}
</select>
<resultMap type=
"one.to.one.Classes"
id=
"getClassesMap"
>
<id column=
"cid"
property=
"cid"
/>
<result column=
"cname"
property=
"cname"
/>
<association property=
"teacher"
javaType=
"one.to.one.Teacher"
>
<id column=
"tid"
property=
"tid"
></id>
<result column=
"tname"
property=
"tname"
/>
</association>
</resultMap>
<!--
方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型
SELECT * FROM classes WHERE cid=
1
;
SELECT * FROM teacher WHERE tid=
1
//1 是上一个查询得到的tid的值
property:别名(属性名) column:列名 -->
<!-- 把teacher的字段设置进去 -->
<select id=
"getClasses2"
resultMap=
"getClassesMap2"
>
select * from classes c where c.cid = #{cid}
</select>
<resultMap type=
"one.to.one.Classes"
id=
"getClassesMap2"
>
<id column=
"cid"
property=
"cid"
/>
<result column=
"cname"
property=
"cname"
/>
<collection property=
"teacher"
column=
"tid"
select=
"getTeacherCollection"
>
</collection>
</resultMap>
<select id=
"getTeacherCollection"
resultType=
"one.to.one.Teacher"
>
select tid tid,tname tname from teacher where tid=#{tid}
</select>
</mapper>
说明:我们这里一对一的关联操作,有两种方式:
1、使用嵌套结果映射来处理重复的联合结果的子集
2、通过执行另外一个SQL映射语句来返回预期的复杂类型
相关属性解释:
④、向 mybatis-configuration.xml 配置文件中注册 classesMapper.xml 文件
⑤、编写测试类
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
package
one.to.one;
import
java.io.InputStream;
import
org.apache.ibatis.session.SqlSession;
import
org.apache.ibatis.session.SqlSessionFactory;
import
org.apache.ibatis.session.SqlSessionFactoryBuilder;
import
org.junit.Before;
import
org.junit.Test;
import
com.ys.test.MyBatisTest;
public
class
OneToOneTest {
SqlSession session;
@Before
public
void
beforeLoadXML(){
//加载 mybatis 配置文件
InputStream inputStream = MyBatisTest.
class
.
getClassLoader().getResourceAsStream(
"mybatis-configuration.xml"
);
//构建sqlSession的工厂
SqlSessionFactory sqlSessionFactory =
new
SqlSessionFactoryBuilder().build(inputStream);
//根据 sqlSessionFactory 产生 session
session = sqlSessionFactory.openSession();
}
//一对一嵌套结果方式:根据班级id查询教师信息
@Test
public
void
testGetTeacher(){
String statement =
"one.to.one.classesMapper.getTeacher"
;
Teacher t = session.selectOne(statement,
1
);
System.out.println(t);
}
//一对一嵌套查询方式:根据教师id查询班级信息
@Test
public
void
testGetClasses2(){
String statement =
"one.to.one.classesMapper.getClasses2"
;
Classes c = session.selectOne(statement,
1
);
System.out.println(c);
}
}
4、MyBatis 入门实例 一对多,多对一 基于xml配置
这里我们以班级和学生为例,一个班级里面对应多个学生,这是一对多;反过来,多个学生对应一个班级,这是多对一
①、建立学生和班级的实体类
Student.java
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
package
one.to.many;
public
class
Student {
private
int
sid;
private
String sname;
private
Classes classes;
public
int
getSid() {
return
sid;
}
public
void
setSid(
int
sid) {
this
.sid = sid;
}
public
String getSname() {
return
sname;
}
public
void
setSname(String sname) {
this
.sname = sname;
}
public
Classes getClasses() {
return
classes;
}
public
void
setClasses(Classes classes) {
this
.classes = classes;
}
@Override
public
String toString() {
return
"Student [sid="
+ sid +
", sname="
+ sname +
", classes="
+ classes +
"]"
;
}
}
Classes.java
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
package
one.to.many;
import
java.util.Set;
public
class
Classes {
private
int
cid;
private
String cname;
private
Set<Student> students;
public
int
getCid() {
return
cid;
}
public
void
setCid(
int
cid) {
this
.cid = cid;
}
public
String getCname() {
return
cname;
}
public
void
setCname(String cname) {
this
.cname = cname;
}
public
Set<Student> getStudents() {
return
students;
}
public
void
setStudents(Set<Student> students) {
this
.students = students;
}
@Override
public
String toString() {
return
"Classes [cid="
+ cid +
", cname="
+ cname +
", students="
+ students +
"]"
;
}
}
②、在数据库中根据实体类创建相应的数据表
③、多对一:定义操作 Classes 表的sql映射文件classesMapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version=
"1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
>
<mapper namespace=
"one.to.many.classesMapper"
>
<select id=
"getClasses"
resultMap=
"getClassesMap"
>
select * from classes c,student s where s.cid=c.cid and c.cid=#{cid}
</select>
<resultMap type=
"one.to.many.Classes"
id=
"getClassesMap"
>
<id column=
"cid"
property=
"cid"
></id>
<result column=
"cname"
property=
"cname"
/>
<collection property=
"students"
ofType=
"one.to.many.Student"
>
<id column=
"sid"
property=
"sid"
/>
<result column=
"sname"
property=
"sname"
/>
</collection>
</resultMap>
</mapper>
④、一对多:定义操作 Student 表的sql映射文件studentMapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version=
"1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
>
<mapper namespace=
"many.to.one.studentMapper"
>
<select id=
"getStudents"
resultMap=
"getStudentMap"
>
select * from classes c,student s where s.cid=c.cid and s.sid=#{sid}
</select>
<resultMap type=
"one.to.many.Student"
id=
"getStudentMap"
>
<id column=
"sid"
property=
"sid"
></id>
<result column=
"sname"
property=
"sname"
/>
<association property=
"classes"
javaType=
"one.to.many.Classes"
>
<id column=
"cid"
property=
"cid"
/>
<result column=
"cname"
property=
"cname"
/>
</association>
</resultMap>
</mapper>
⑤、向 mybatis-configuration.xml 配置文件中注册 classesMapper.xml 、studentMapper.xml文件
⑥、编写测试类
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
package
one.to.many;
import
java.io.InputStream;
import
org.apache.ibatis.session.SqlSession;
import
org.apache.ibatis.session.SqlSessionFactory;
import
org.apache.ibatis.session.SqlSessionFactoryBuilder;
import
org.junit.Before;
import
org.junit.Test;
import
com.ys.test.MyBatisTest;
public
class
OneToManyTest {
SqlSession session;
@Before
public
void
beforeLoadXML(){
//加载 mybatis 配置文件
InputStream inputStream = MyBatisTest.
class
.
getClassLoader().getResourceAsStream(
"mybatis-configuration.xml"
);
//构建sqlSession的工厂
SqlSessionFactory sqlSessionFactory =
new
SqlSessionFactoryBuilder().build(inputStream);
//根据 sqlSessionFactory 产生 session
session = sqlSessionFactory.openSession();
}
//一对多嵌套结果方式:根据班级id查询班级所有的学生信息
@Test
public
void
testGetClasses(){
String statement =
"one.to.many.classesMapper.getClasses"
;
Classes c = session.selectOne(statement,
1
);
System.out.println(c);
System.out.println(c.getStudents().size());
}
//多对一嵌套结果方式:根据学生id查询班级信息
@Test
public
void
testGetStudents(){
String statement =
"many.to.one.studentMapper.getStudents"
;
Student s = session.selectOne(statement,
1
);
System.out.println(s);
System.out.println(s.getClasses());
}
}
5、MyBatis 入门实例 多对多 基于xml配置
这里我们以 users 表和 groups 表为例,一个 users 可能加入多个 groups,而一个 groups 可能包含多个 users,故构成 多对多 的关联
①、在数据库中建立相应的表
users 表
groups 表
两者之间的关联表users_groups表
②、建立对应的实体类
Users.java
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
package
many.to.many;
import
java.util.Set;
public
class
Users {
private
int
uid;
private
String uname;
private
Set<Groups> groups;
public
int
getUid() {
return
uid;
}
public
void
setUid(
int
uid) {
this
.uid = uid;
}
public
String getUname() {
return
uname;
}
public
void
setUname(String uname) {
this
.uname = uname;
}
public
Set<Groups> getGroups() {
return
groups;
}
public
void
setGroups(Set<Groups> groups) {
this
.groups = groups;
}
@Override
public
String toString() {
return
"User [uid="
+ uid +
", uname="
+ uname +
", groups="
+ groups +
"]"
;
}
}
Groups.java
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
package
many.to.many;
import
java.util.Set;
public
class
Groups {
private
int
gid;
private
String gname;
private
Set<Users> users;
public
int
getGid() {
return
gid;
}
public
void
setGid(
int
gid) {
this
.gid = gid;
}
public
String getGname() {
return
gname;
}
public
void
setGname(String gname) {
this
.gname = gname;
}
public
Set<Users> getUsers() {
return
users;
}
public
void
setUsers(Set<Users> users) {
this
.users = users;
}
@Override
public
String toString() {
return
"Group [gid="
+ gid +
", gname="
+ gname +
", users="
+ users +
"]"
;
}
}
Users_Groups.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package
many.to.many;
public
class
Users_Groups {
private
Users user;
private
Groups group;
public
Users getUser() {
return
user;
}
public
void
setUser(Users user) {
this
.user = user;
}
public
Groups getGroup() {
return
group;
}
public
void
setGroup(Groups group) {
this
.group = group;
}
}
③、多对多:定义操作 sql映射文件userMapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version=
"1.0"
encoding=
"UTF-8"
?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"
>
<mapper namespace=
"many.to.many.userMapper"
>
<!-- 给一个用户 id,查看该用户下的所有用户组信息 -->
<select id=
"getUsers"
resultMap=
"getGroupMap"
>
select g.gid,g.gname from users_groups ug,groups g
where ug.group_id=g.gid and ug.user_id=#{uid}
</select>
<resultMap type=
"many.to.many.Groups"
id=
"getGroupMap"
>
<id column=
"gid"
property=
"gid"
/>
<result column=
"gname"
property=
"gname"
/>
<collection property=
"users"
ofType=
"many.to.many.Users"
>
<id column=
"uid"
property=
"uid"
/>
<result column=
"uname"
property=
"uname"
/>
</collection>
</resultMap>
</mapper>
⑤、向 mybatis-configuration.xml 配置文件中注册 userMapper.xml文件
⑥、编写测试类
1
2
3
4
5
6
7
8
9
//多对多:根据根据用户 id 查询所有的用户组信息
@Test
public
void
testGetGroups(){
String statement =
"many.to.many.userMapper.getUsers"
;
List<Groups> listGroup = session.selectList(statement,
1
);
for
(Groups g : listGroup){
System.out.println(g.toString());
}
}
④、定义表所对应的实体类
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
package
com.ys.bean;
public
class
Person {
private
int
pid;
private
String pname;
private
int
page;
public
int
getPid() {
return
pid;
}
public
void
setPid(
int
pid) {
this
.pid = pid;
}
public
String getPname() {
return
pname;
}
public
void
setPname(String pname) {
this
.pname = pname;
}
public
int
getPage() {
return
page;
}
public
void
setPage(
int
page) {
this
.page = page;
}
@Override
public
String toString() {
return
"Person [pid="
+ pid +
", pname="
+ pname +
", page="
+ page
+
"]"
;
}
}
-
举例说明什么是组合关系什么是聚合关系
2021-01-12 03:05:00展开全部组合关系是指一个单位和同一e5a48de588b662616964757a686964616f31333431363030序列的其他单位间的关系,或共现的所有成分的关系处于组合关系的词必须满足一些句法和语义条件。组合关系也称句段关系,可比作... -
mysql指引(一):mysql到底是什么
2020-01-13 21:06:15主要讲mysql是什么,重点理清“关系”这个概念 -
多对多关系的多表关联查询
2017-11-23 19:14:201.什么是多对多关系 多对多关系 (百度): 多对多关系是关系数据库中两个表之间的一种关系, 该关系中第一个表中的一个行可以与第二个表中的一个或多个行相关。第二个表中的一个行也可以与第一个表中的一个或... -
汉字关联性量化方法及其在文本相似性分析中的应用 (2006年)
2021-05-13 10:26:04首先定义了文本中汉字与汉字之间关系的量化方法,提出汉字关联度的概念,然后构造汉字关联度矩阵来表示汉语文本,并设计了一种基于汉字关联度矩阵的汉语文本相似性度量算法。实验结果表明,汉字关联度优于二字词词频... -
UML关联关系
2012-07-06 10:49:53UML中的关联关系其内在意思就是has a 相对于依赖关系,关联关系在代码中有所体现.上图中的关联关系在代码中体现为 其中water 中将Climate作为其中的属性. 当然,关联关系中也有双相关联 关联又分为组合,... -
助记词是什么,有什么用?
2019-02-04 19:36:34助记词是什么,有什么用? 玩加密货币的朋友相信对助记词都不陌生,我们在使用钱包之前,会让你备份12个单词,在备份期间不允许截图操作,并且不断强调这12个单词非常重要,最好用物理方式备份,备份时身边... -
组合、聚合、关联之间的区别和关系
2013-11-19 16:31:09关于 csdn 上有一个同行做了详细的分析,写的很不错。我这里懒了,直接转过来作为备份。 用C++程序的话,聚合就像是类中的指针成员,而组合就是类中的成员. 类间关系 在类图中,除了需要描述单独的类的名称、属性... -
[Python知识图谱] 四.Python和Gephi实现中国知网合作关系知识图谱
2019-09-02 16:47:35本篇文章主要采用Python和Gephi构建中国知网某个领域的作者合作关系和主题词共现的知识图谱,重点阐述了一种可操作的关系图谱构建方法,可用于论文发表、课程或企业可视化展示等。其基本步骤如下:1.在中国知网搜索... -
SCI论文写作中常用的连接词和短语
2021-12-27 21:20:05SCI-关联词 SCI论文写作中常用的连接词和短语。 描述相似性连词 英文 中文 Likewise 同样地 Correspondongly 相应地 Equally 同样地 Not only…but also 不仅…而且 In the same way 以同样的方式 ... -
NLP系列(10)_词向量之图解Word2vec
2019-04-08 09:58:35审校:龙心尘 作者:Jay Alammar 编译:张秋玥、毅航、高延 ...原文链接: https://jalammar.github.io/illustrated-word2vec/ 嵌入(embedding)是机器学习中最迷人的想法之一。 如果你曾经使用Siri、Google... -
科普:大数据、人工智能、机器学习与深度学习都是什么?有什么关系?
2018-06-21 21:00:00导读:大数据、人工智能是目前大家谈论比较多的话题,它们的应用也越来越广泛、与我们的生活关系也越来越密切,影响也越来越深远,其中很多已进入寻常百姓家,如无人机、网约车、自动... -
语言学纲要 举例说明什么叫组合关系,什么叫聚合关系
2021-01-12 03:04:58展开全部组合关系也称62616964757a686964616fe4b893e5b19e31333431343632句段关系,可比作横向水平关系,指一个语言元素与另一语言元素同时排列在言语链条上,构成语言要素在现场的组合,如在“快来”这个句子中,... -
Elasticsearch文档内部的父子关系
2021-11-20 10:59:42Elasticsearch中的父子关系是单个索引内部文档与文档之间的一种关系,父文档与子文档同属一个索引并通过父文档id建立联系, 类似于关系型数据库中单表内部行与行之间的自关联,比如有层级关系的部门表中记录之间的... -
常用分析方法——矩阵关联分析
2021-01-06 23:31:33一、矩阵关联分析(象限分析法) 定义 将事物的两个重要指标作为分析的依据,进行分类关联分析,找出解决问题的一种分析方法,也称为矩阵关联分析法,简称矩阵分析(或象限分析)。 作用 (1)将有相同特征的事件...