如果设置了ssh链接方式,并且已经设置好了本地的id_rsa和远程服务器上的authorized_keys,但每次pull和git还是需要密码,那很有可能是远程服务器上/home/git/ &, &/home/git/.ssh/ &, &/home/git/.ssh/authorized_keys &这三个权限的问题, 你可以登陆远程服务器,查看ssh登陆日志:
tail /var/log/secure -n 20
如果发现类似这些语句:
Authentication refused: bad ownership or modes for file /home/git/.ssh/authorized_keys
Authentication refused: bad ownership or modes for directory /home/git/.ssh
Authentication refused: bad ownership or modes for directory /home/git
就相应的进行设置权限就可以了:
chmod 700 /home/your_user
chmod 700 /home/your_user/.ssh
chmod 600 /home/your_user/.ssh/authorized_keys
& 著作权归作者所有
人打赏支持
码字总数 12053
Git是一个分布式版本控制软件，原来是linux内核开发者Linus Torvalds为了更好地管理linux内核开发而创立的。发展至今，Git已经成为了一个相当好用的版本管理工具。相比于SVN，如果想要保存一...
其实没有管理代码的需求，只是在公司用公司的电脑，在自己家用自己的电脑，在父母家用父母的电脑。一份代码来回拷的话的确有点恶心。有人说放在网盘里，DropBox被墙，MicroSoft的SkyDrive又不...
本文写的针对Git有一定的基础的使用者。初学的话可以参考这个系列教程，还有git - 简明指南 首先说一下背景 两个邮箱 /, 我有两个git账号，一个公司（github）A@gmail...
1.首先检查一下自己的mac上有没有安装git: 在终端运行 $git --version 正常会返回当前git的版本 比如 git version 2.5.3。如果还没有安装git 建议使用brew安装(好吧 前提是已经安装了brew！)...
github windows git git是什么 git有什么特点 设置 git config --global user.name '你的用户名' git config --global user.email '你的邮箱' 通过 key 关联本地库和远程库 github 账号请自己...
本文主要目的是想让和我一样刚从SVN阵营转到Git阵营的程序员能够快速完成一些简单的Git操作。 简单理解 Git 的思想和基本的工作原理，能够更好的进一步和使用Git。在开始学习Git 的时候，最好...
之前闲暇之余尝试着在github上搭建自己的博客，搭建过程中发现没有自己想象的那么容易，几经波折，好不容易才搭建好了雏形。现在就将在github上构建自己博客的整个流程好好总结一下。 注：本...
很多人认为Git太混乱或太复杂而没有把它当做版本控制工具。然而Git正在成长，另外很多很有意思的事情也随之发展起来。这篇文章瞄准了想开始用Git的人群，通常是从Subversion（另一个版本控制...
浮躁的码农
获取Git软件： 大家可以通过两种方式获取Git的软件，一个是在官网上获取，另一个可以点击这里下载。只是有一点需要说明就是需要下载支持WinXp系统的版本。 Git在WinXP安装过程 在WinXP下安装...
本地Git仓库和GitHub仓库之间的传输是通过SSH加密的，所以，需要一点设置： 第1步：创建SSH Key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有和这两个文件，如果已...
没有更多内容
加载失败，请刷新页面
现代软件架构的复杂性需要协同开发完成，如何高效地协同呢？无规矩不成方圆，无规范难以协同，比如，制订交通法规表面上是要限制行车权，实际上是保障公众的人身安全，试想如果没有限速，没有...
10.23 linux任务计划cron 10.24 chkconfig工具 10.25 systemd管理服务 10.26 unit介绍 10.27 target介绍 10.23 linux任务计划cron： 在linux中任务计划是必不可少的，因为可能我们凌晨的时候...
logback.xml config &?xml version="1.0" encoding="UTF-8"?&&configuration&
&conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.Colo......
告警系统邮件引擎 因为之前做zabbix的时候，做过mail.py的脚本，在这里，直接调用进行使用就可以。 但是告警邮件引擎核心，conf主配置文件调用到的都是mail.sh ，所以这里需要定义调用mail....
什么是微服务 首先微服务并没有一个官方的定义，想要直接描述微服务比较困难，我们可以通过对比传统WEB应用，来理解什么是微服务。 传统的WEB应用核心分为业务逻辑、适配器以及API或通过UI访...
Java大蜗牛
The Spark Streaming integration for Kafka 0.10 is similar in design to the 0.8 Direct Stream approach. It provides simple parallelism, 1:1 correspondence between Kafka partition......
一个数组的例子，实现查找，显示和删除的功能。 在这个数组中存储的数据类型是long型，使用long型为的是表明这是数据，而int型被用来表示下标。通常数据结构存储的数据项包含有好几个字段，所...
沉迷于编程的小菜菜
Python3 基于 requests 批量下载图片 import requestsheaders = {'Accept': 'text/html,application/xhtml+xml,application/q=0.9,image/webp,image/apng,*/*;q=0.8','Accept-Encod......
/** * 当前时间所在一周的周一和周日时间 * @param time 当前时间 * @return */ public static Map getWeekDate(String time) { Map map = new HashedMap(); SimpleDateFormat sdf = new Si......
网上有些文章已经不再适用，本人也是踩了些坑，在此记录下。 迁移redis数据一般有如下3种方式： 第三方工具redis-dump，redis-load aof机制，需要开启aof功能 rdb存储机制 这里介绍第一种方式...
没有更多内容
加载失败，请刷新页面
文章删除后无法恢复，确定取消删除此文章吗？
亲，自荐的博客将通过私信方式通知管理员，优秀的博客文章审核通过后将在博客推荐列表中显示
确定推荐此文章吗？
确定推荐此博主吗？
聚合全网技术文章，根据你的阅读喜好进行个性推荐
指定官方社区
深圳市奥思网络科技有限公司版权所有Hibernate关联映射——一对多（多对一）
Hibernate关联映射——一对多（多对一）
我们以客户(Customer)与订单(Order)为例来讲解Hibernate关联映射中的一对多关联关系。
首先肯定是搭建好Hibernate的开发环境，我在此也不过多赘述，读者自行实践。接着在src目录下创建一个cn.itheima.oneToMany包，并在该包下创建两个实体类，如下：
public class Customer {
private Set&Order& orders = new HashSet&Order&();
public Set&Order& getOrders() {
public void setOrders(Set&Order& orders) {
this.orders =
public Integer getId() {
public void setId(Integer id) {
public String getName() {
public void setName(String name) {
this.name =
public class Order {
private String receiverI
public Customer getC() {
public void setC(Customer c) {
public Integer getId() {
public void setId(Integer id) {
public Double getMoney() {
public void setMoney(Double money) {
this.money =
public String getReceiverInfo() {
return receiverI
public void setReceiverInfo(String receiverInfo) {
this.receiverInfo = receiverI
完成之后，再在cn.itheima.oneToMany包下分别编写这两个类的映射配置文件。
Customer.hbm.xml
&?xml version="1.0"?&
&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&
name="cn.itheima.oneToMany.Customer" table="t_customer"&
name="id" column="c_id"&
class="identity" /&
name="name" column="c_name" length="20" /&
name="orders"&
column="c_customer_id" /&
class="cn.itheima.oneToMany.Order" /&
Order.hbm.xml
&?xml version="1.0"?&
&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&
name="cn.itheima.oneToMany.Order" table="t_order"&
name="id" column="c_id"&
class="identity" /&
name="money" column="c_money" /&
name="receiverInfo" column="c_receiverInfo" length="50" /&
name="c" class="cn.itheima.oneToMany.Customer" column="c_customer_id"&
测试双向关联保存
现在我们来测试保存的操作，在src目录下创建一个cn.itheima.test包，并在该包下编写一个OneToManyTest单元测试类，然后在该类中编写一个用于测试保存的操作，如下：
public class OneToManyTest {
public void test1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("张三");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("上海");
o1.setC(c);
o2.setC(c);
c.getOrders().add(o1);
c.getOrders().add(o2);
session.save(o1);
session.save(o2);
session.save(c);
session.getTransaction().commit();
session.close();
测试test1方法，运行正常。其实上面测试保存的操作就是一种双向关联关系，如果做的是双向的关联，而没有用cascade去做级联，那么就存在一个浪费的环节，后面会讲。
顺其自然地，我们就会想可不可以只保存订单或只保存客户就能完成保存的操作呢？答案是不言而喻的。下面我就来简单地讲讲。
测试单向关联保存
现在我们只想保存订单，然后顺便保存客户，可以预想到的是我们可能会这样写代码：
public class OneToManyTest {
public void test2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("张三");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("上海");
o1.setC(c);
o2.setC(c);
session.save(o1);
session.save(o2);
session.getTransaction().commit();
session.close();
这时测试以上方法，会发现报如下异常：
org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: cn.itheima.oneToMany.Customer
at org.hibernate.engine.internal.ForeignKeys.getEntityIdentifierIfNotUnsaved(ForeignKeys.java:279)
at org.hibernate.type.EntityType.getIdentifier(EntityType.java:455)
at org.hibernate.type.ManyToOneType.isDirty(ManyToOneType.java:281)
at org.hibernate.type.ManyToOneType.isDirty(ManyToOneType.java:291)
at org.hibernate.type.TypeHelper.findDirty(TypeHelper.java:296)
at org.hibernate.persister.entity.AbstractEntityPersister.findDirty(AbstractEntityPersister.java:4081)
at org.hibernate.event.internal.DefaultFlushEntityEventListener.dirtyCheck(DefaultFlushEntityEventListener.java:532)
at org.hibernate.event.internal.DefaultFlushEntityEventListener.isUpdateNecessary(DefaultFlushEntityEventListener.java:215)
at org.hibernate.event.internal.DefaultFlushEntityEventListener.onFlushEntity(DefaultFlushEntityEventListener.java:142)
at org.hibernate.event.internal.AbstractFlushingEventListener.flushEntities(AbstractFlushingEventListener.java:216)
at org.hibernate.event.internal.AbstractFlushingEventListener.flushEverythingToExecutions(AbstractFlushingEventListener.java:85)
at org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:38)
at org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1282)
at org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:465)
at org.hibernate.internal.SessionImpl.flushBeforeTransactionCompletion(SessionImpl.java:2963)
at org.hibernate.internal.SessionImpl.beforeTransactionCompletion(SessionImpl.java:2339)
at org.hibernate.engine.jdbc.internal.JdbcCoordinatorImpl.beforeTransactionCompletion(JdbcCoordinatorImpl.java:485)
at org.hibernate.resource.transaction.backend.jdbc.internal.JdbcResourceLocalTransactionCoordinatorImpl.beforeCompletionCallback(JdbcResourceLocalTransactionCoordinatorImpl.java:147)
at org.hibernate.resource.transaction.backend.jdbc.internal.JdbcResourceLocalTransactionCoordinatorImpl.access$100(JdbcResourceLocalTransactionCoordinatorImpl.java:38)
at org.hibernate.resource.transaction.backend.jdbc.internal.JdbcResourceLocalTransactionCoordinatorImpl$TransactionDriverControlImpl.commit(JdbcResourceLocalTransactionCoordinatorImpl.java:231)
at org.hibernate.engine.transaction.internal.TransactionImpl.commit(TransactionImpl.java:65)
at cn.itheima.test.OneToManyTest.test2(OneToManyTest.java:43)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)
这个异常代表一个持久化对象关联了一个瞬时对象。出现问题，就要着手解决，那又怎么解决呢？我们可以使用级联操作来解决上述的问题，我们现在要做的是保存订单时保存客户，那么需要在订单类的映射配置文件中进行修改：
&many-to-one name="c" class="cn.itheima.oneToMany.Customer" column="c_customer_id" cascade="save-update"&&/many-to-one&
设置了cascade=save-update，那么在保存订单时就可以自动将客户保存了。这时再次执行test2方法，发现一切正常。
现在我们又想要在完成保存客户时，保存订单，那又该怎么做呢？答案是不言而喻的，用屁股想都能知道，在客户类的映射配置文件中进行修改：
&set name="orders" cascade="save-update"&
&key column="c_customer_id" /&
&one-to-many class="cn.itheima.oneToMany.Order" /&
设置了cascade=save-update，那么在保存客户时就可以自动将订单保存了。这时我们在OneToManyTest单元测试类再编写一个方法进行测试：
public class OneToManyTest {
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("张三");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("上海");
c.getOrders().add(o1);
c.getOrders().add(o2);
session.save(c);
session.getTransaction().commit();
session.close();
双向关联维护
我们在开发中要配置双向关联配置，这样就可以通过任意一方来操作对方。但在写操作代码时，尽量要进行单向关联，这样可以尽量减少资源浪费。在前面测试双向关联保存那一小节中，我讲到存在一个资源浪费的问题，在这一节我就会细讲。
回到最初测试双向关联保存的位置，如果像那样测试test1方法，那么Eclipse控制台会打印如下sql语句：
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
t_customer
-------------------------自己加的分割线-------------------------------
Hibernate:
c_money=?,
c_receiverInfo=?,
c_customer_id=?
Hibernate:
c_money=?,
c_receiverInfo=?,
c_customer_id=?
Hibernate:
c_customer_id=?
Hibernate:
c_customer_id=?
发现有4条update语句，为什么会这样昵？原因非常简单，我们现在这个操作，是做了一个双向关联，那么订单和客户都会去维护c_customer_id这个
外键，也就是说当我们插订单的时候，c_customer_id是没值的，因为还没有Customer，所以它插入的是一个null值。当我们插完订单以后，再去插入客户，
客户有了，我们就需要对订单里面的c_customer_id去修改，所以就会出现这样一种情况。
在双向关联中，会存在多余的update语句，这个存在虽然不影响我们的程序运行，但是会影响性能，因为它在浪费资源。所以在写操作代码时，尽量要进行单向关联，但如果我们非得进行双向关联呢？那又该怎么减少资源浪费呢？这时我们可以使用inverse属性来设置，双向关联时由哪一方来维护表与表之间的关系。通常我们都会在多的一方维护关联关系，所以最好由订单类来维护双向关联关系，那么客户类的映射配置文件应修改为：
&set name="orders" inverse="true"&
&key column="c_customer_id" /&
&one-to-many class="cn.itheima.oneToMany.Order" /&
inverse的值如果为true，代表由对方来维护外键。
inverse的值如果为false，代表由本方来维护外键。
关于inverse的取值有这样一个原则：外键在哪一个表中，我们就让哪一方来维护外键。
就这样简简单单修改之后，再次测试test1方法，Eclipse控制台会打印如下sql语句：
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
t_customer
-------------------------自己加的分割线-------------------------------
Hibernate:
c_money=?,
c_receiverInfo=?,
c_customer_id=?
Hibernate:
c_money=?,
c_receiverInfo=?,
c_customer_id=?
可发现update语句是少了两条的。
一对多的对象导航
下面来看看一对多的对象导航问题，如图：
下面我们编写代码来进行演示，在OneToManyTest单元测试类编写如下测试方法：
public class OneToManyTest {
public void test4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = new Customer();
c.setName("张三");
Order o1 = new Order();
o1.setMoney(1000d);
o1.setReceiverInfo("武汉");
Order o2 = new Order();
o2.setMoney(2000d);
o2.setReceiverInfo("上海");
Order o3 = new Order();
o3.setMoney(3000d);
o3.setReceiverInfo("天门");
o1.setC(c);
c.getOrders().add(o2);
c.getOrders().add(o3);
session.save(o1);
session.getTransaction().commit();
session.close();
运行以上方法，可发现Eclipse控制台打印出如下sql语句：
Hibernate:
t_customer
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
Hibernate:
(c_money, c_receiverInfo, c_customer_id)
所以共插入4条记录。其他情况请读者自行测试。
现在我们有这样一个需求：当我们删除一个客户时，应该将客户对应的订单也删除(实际开发中删除订单时，是不需要删除客户的)。首先查看一下客户类和订单类的映射配置文件：
Customer.hbm.xml
&?xml version="1.0"?&
&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&
name="cn.itheima.oneToMany.Customer" table="t_customer"&
name="id" column="c_id"&
class="identity" /&
name="name" column="c_name" length="20" /&
name="orders" inverse="true" cascade="save-update"&
column="c_customer_id" /&
class="cn.itheima.oneToMany.Order" /&
Order.hbm.xml
&?xml version="1.0"?&
&!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&
name="cn.itheima.oneToMany.Order" table="t_order"&
name="id" column="c_id"&
class="identity" /&
name="money" column="c_money" /&
name="receiverInfo" column="c_receiverInfo" length="50" /&
name="c" class="cn.itheima.oneToMany.Customer" column="c_customer_id" cascade="save-update"&
大家的映射配置文件是不是上面这样的，如果是的话，可以在OneToManyTest单元测试类编写一个方法进行测试：
public class OneToManyTest {
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = session.get(Customer.class, 1);
session.delete(c);
session.getTransaction().commit();
session.close();
我们在删除客户时，也要删除订单，如果没有做级联删除的话，那么这个操作是不被允许的，原因是为了维护数据完整性。如果我们想要完成操作，可以在客户类的映射文件中添加cascade="delete"，如下：
&set name="orders" inverse="true" cascade="delete"&
&key column="c_customer_id" /&
&one-to-many class="cn.itheima.oneToMany.Order" /&
delete-orphan用法
delete-orphan(删除孤儿) ：删除与当前对象解除关系的对象。
现举例来演示delete-orphan的用法，在OneToManyTest单元测试类编写如下一个方法：
public class OneToManyTest {
public void test6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Customer c = session.get(Customer.class, 1);
Order o = session.get(Order.class, 1);
c.getOrders().remove(o);
session.getTransaction().commit();
session.close();
这时运行以上方法，发现id为1的订单并没有被删除。如果想起到我们预期的效果，可以在客户类的映射文件中添加cascade="delete-orphan"，如下：
&set name="orders" inverse="true" cascade="delete-orphan"&
&key column="c_customer_id" /&
&one-to-many class="cn.itheima.oneToMany.Order" /&
cascade总结
使用cascade可以完成级联操作，它的常用可取值：
none：这是一个默认值
save-update：当我们配置它时，底层使用save、update或saveOrUpdate完成操作，级联保存临时对象，如果是游离对象，会执行update
delete：级联删除
delete-orphan：删除与当前对象解除关系的对象
all：它包含了save-update、delete操作
all-delete-orphan：它包含了delete-orphan与all操作
没有更多推荐了，个人blog: blog.moguang.me
【OpsDev】解决mac下ssh空闲一段时间自动断开的问题
在macbook中使用终端, 通过ssh连接上远程服务器后, 隔一段时间没有数据传递时会自动断开，而表象就是终端会卡着无响应，要等几分钟后才会显示断开并且返回到本地终端命令行。这个问题太影响流畅性和心情， 决定修一修。
第一种方法， 在本地或者远程服务器修改ssh配置, 定时发起类似心跳的信号。
1)在服务器中的/etc/ssh/sshd_config中去掉原有注释并改成这样:
ClientAliveInterval 60
ClientAliveCountMax 3ClientAliveInterval 60表示每分钟发送一次, 然后客户端响应, 从而保持长连接. ClientAliveCountMax表示服务器发出请求后客户端没有响应的次数达到3次, 就自动断开。
2)在客户端中的/etc/ssh/ssh_ssh_config中去掉注释并改成这样:
ServerAliveInterval 60
ServerAliveCountMax 2对应的意义与上面类似。
第二种方法，使用autossh, 它会在ssh断开后自动再连接上。
目前我用的是这个版本: https://github.com/wufeifei/autossh
第三种方法，使用mosh工具， 参考 。
据说是神器， 不过我没用上。
没有更多推荐了，