学生 package hx.nan.entity; import org.hibernate.annotations.Cascade; import org.hibernate.annotations.CascadeType; import org.hibernate.annotations.GenericGenerator; import javax.persistence.*; @Entity @Table(name = "student") public class Student { private int id; private String name; private int age; private Grade grade; public Student() { } public Student(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } @Id @GenericGenerator(name = "id",strategy = "assigned") @GeneratedValue(generator = "id") @Column(name = "id", nullable = false) public int getId() { return id; } public void setId(int id) { this.id = id; } @Basic @Column(name = "name", nullable = false, length = 255) public String getName() { return name; } public void setName(String name) { this.name = name; } @Basic @Column(name = "age", nullable = false) public int getAge() { return age; } public void setAge(int age) { this.age = age; } @ManyToOne(fetch = FetchType.LAZY) @Cascade(CascadeType.SAVE_UPDATE) @JoinColumn(name = "grade_id",referencedColumnName = "id") public Grade getGrade() { return grade; } public void setGrade(Grade grade) { this.grade = grade; } } ``` package hx.nan.entity; import org.hibernate.annotations.GenericGenerator; import javax.persistence.*; import java.util.HashSet; import java.util.Set; 年级 @Entity @Table(name = "grade") public class Grade { private int id; private String gradeNumber; private Set<Student> students = new HashSet<>(); public Grade() { } public Grade(int id, String gradeNumber) { this.id = id; this.gradeNumber = gradeNumber; } @Id @GenericGenerator(name = "id",strategy = "assigned") @GeneratedValue(generator = "id") @Column(name = "id", nullable = false) public int getId() { return id; } public void setId(int id) { this.id = id; } @Basic @Column(name = "grade_number", nullable = false, length = 255) public String getGradeNumber() { return gradeNumber; } public void setGradeNumber(String gradeNumber) { this.gradeNumber = gradeNumber; } @OneToMany(mappedBy = "grade") public Set<Student> getStudents() { return students; } public void setStudents(Set<Student> students) { this.students = students; } } ``` 测试代码 package hx.nan; import hx.nan.entity.Grade; import hx.nan.entity.Student; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; public class AnnotationTestTest { @Test public void testTestManyToOne() throws Exception { Student s1 = new Student(1,"zhangsan",20); Student s2 = new Student(2, "lisi", 30); Grade grade = new Grade(1, "1班"); s1.setGrade(grade); s2.setGrade(grade); Session session = HibernateSessionFactory.getSession(); Transaction tx = session.beginTransaction(); session.save(s1); session.save(s2); tx.commit(); session.close(); HibernateSessionFactory.closeSessionFactory(); } } Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Cannot add or update a child row: a foreign key constraint fails (`hib`.`student`, CONSTRAINT `FK4xvaqcll34afqdd9vkydid5qo` FOREIGN KEY (`grade_id`) REFERENCES `grade` (`id`)) at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at com.mysql.jdbc.Util.handleNewInstance(Util.java:404) at com.mysql.jdbc.Util.getInstance(Util.java:387) at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:932) at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3878) at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3814) at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2478) at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2625) at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2551) at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1861) at com.mysql.jdbc.PreparedStatement.executeUpdateInternal(PreparedStatement.java:2073) at com.mysql.jdbc.PreparedStatement.executeUpdateInternal(PreparedStatement.java:2009) at com.mysql.jdbc.PreparedStatement.executeLargeUpdate(PreparedStatement.java:5094) at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:1994) at org.hibernate.engine.jdbc.internal.ResultSetReturnImpl.executeUpdate(ResultSetReturnImpl.java:204) ... 45 more ``` 只有在生成策略为assigned时报错，在将一方的生成策略删除后就能正常执行，而且在年级一方也不能配置@GeneratedValue 配置后报同样的错（多方配置不出错），但是如果将上面代码的生成策略改为uuid（id类型改为String）后代码正常运行（两边都可以配置），到底是哪的问题，assigned不是由程序赋值吗？明显赋值了，但是年级方一旦配置assigned就不会级联保存（学生方配置级联保存），就会报上面的错

使用hibernate uuid注解 自动生成id值，在students和courses多对多的级联保存时， id保存出错 报错代码如下 ``` log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version). log4j:WARN Please initialize the log4j system properly. Hibernate: insert into students (sname, id) values (?, ?) Hibernate: insert into courses (cname, id) values (?, ?) Hibernate: insert into courses (cname, id) values (?, ?) Hibernate: insert into students_courses (sid, cid) values (?, ?) Hibernate: insert into students_courses (sid, cid) values (?, ?) org.hibernate.exception.GenericJDBCException: Could not execute JDBC batch update at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:126) at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:114) at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66) at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275) at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:266) at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:171) at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321) at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50) at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1027) at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:365) at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:137) at com.caidi.Test.TestManyToManyEach.test01(TestManyToManyEach.java:41) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:69) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:48) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:231) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:50) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222) at org.junit.runners.ParentRunner.run(ParentRunner.java:292) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197) Caused by: java.sql.BatchUpdateException: Field 'id' doesn't have a default value at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:1693) at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1108) at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70) at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268) ... 31 more ``` 1. Students类 ``` package com.caidi.beans; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.Table; import org.hibernate.annotations.Cascade; import org.hibernate.annotations.CascadeType; import org.hibernate.annotations.GenericGenerator; @Entity @Table(name="students") public class Students { @Id @GeneratedValue(generator="system-uuid") @GenericGenerator(name="system-uuid", strategy = "uuid.hex") @Column(name="id") private String id; @Column(name="sname") private String sname; @ManyToMany @Cascade(value={CascadeType.SAVE_UPDATE}) @JoinTable(name="students_courses",joinColumns={@JoinColumn(name="sid",referencedColumnName="id")},inverseJoinColumns={@JoinColumn(name="cid",referencedColumnName="id")}) private List<Courses> courses; public Students() { super(); } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } public List<Courses> getCourses() { return courses; } public void setCourses(List<Courses> courses) { this.courses = courses; } } ``` 2. Courses类 ``` package com.caidi.beans; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.ManyToMany; import javax.persistence.Table; import org.hibernate.annotations.Cascade; import org.hibernate.annotations.CascadeType; import org.hibernate.annotations.GenericGenerator; @Entity @Table(name="courses") public class Courses { @Id @GeneratedValue(generator="system-uuid") @GenericGenerator(name="system-uuid", strategy = "uuid.hex") @Column(name="id") private String id; @Column(name="cname") private String cname; @ManyToMany(mappedBy="courses")//ManyToMany默认lazy加载 @Cascade(value={CascadeType.SAVE_UPDATE}) private List<Students> students; public Courses() { super(); } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getCname() { return cname; } public void setCname(String cname) { this.cname = cname; } public List<Students> getStudents() { return students; } public void setStudents(List<Students> students) { this.students = students; } } ``` 3. Students_Courses.java ``` package com.caidi.beans; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Table; import org.hibernate.annotations.GenericGenerator; @Entity @Table(name="students_courses") public class Students_Courses { private String id; @Column(name="sid") private String sid; @Column(name="cid") private String cid; public Students_Courses() { super(); } @Id @GeneratedValue(generator="system-uuid") @GenericGenerator(name="system-uuid", strategy = "uuid.hex") @Column(name="id") public String getId() { return id; } public void setId(String id) { this.id = id; } public String getSid() { return sid; } public void setSid(String sid) { this.sid = sid; } public String getCid() { return cid; } public void setCid(String cid) { this.cid = cid; } } ``` 4. 测试代码 ``` package com.caidi.Test; import java.util.ArrayList; import java.util.Date; import java.util.List; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com.caidi.beans.Courses; import com.caidi.beans.Students; import com.caidi.utils.HibernateTools; public class TestManyToManyEach { @Test public void test01(){ Session session = HibernateTools.getSession(); //开启事物 Transaction tr = session.beginTransaction(); try{ Courses c1 = new Courses();Courses c2 = new Courses(); c1.setCname("数学课"); c2.setCname("语文课"); List list1 = new ArrayList(); list1.add(c1);list1.add(c2); Students s1 = new Students(); s1.setSname("小明"); s1.setCourses(list1); session.save(s1); tr.commit(); System.out.println("finsh"); }catch(Exception e){ tr.rollback(); e.printStackTrace(); }finally{ if(session.isOpen() ==true){ session.close(); } } } } ``` mysql数据库   

2张表A,B A表中有一外键指向B表的主键，用@OneToOne(targetEntity = B.class,fetch = FetchType.LAZY) 注解后，利用hibernate自动生成的表中，B表中也对应出现了A表的外键字段，我现在希望A表中有B的外键但B中不能有A的外键，请问该怎么设置？ A：id, name,B_id B:id,name

先说明见一下：总共有两个表，一个是teacher,另一个是student，多对多关系，都分别有序列S_Teacher和S_Student，使用oracle9i数据库，hibernate3.3，spring2.5和JPA的注解 下面是我的源代码： Teacher model [code="java"] import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.ManyToMany; import javax.persistence.SequenceGenerator; import javax.persistence.Table; @Entity @Table(name = "Teacher") public class Teacher implements java.io.Serializable { /** * */ private static final long serialVersionUID = 1L; @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="S_Teacher") @SequenceGenerator(name="S_Teacher",allocationSize=1,initialValue=1, sequenceName="S_Teacher") private Long tid; private String tname; private Integer tage; private Date tcreateDate; @ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY, mappedBy = "teachers", targetEntity = Student.class) private List<Student> students=new ArrayList<Student>(); public Long getTid() { return tid; } public void setTid(Long tid) { this.tid = tid; } public String getTname() { return tname; } public void setTname(String tname) { this.tname = tname; } public Integer getTage() { return tage; } public void setTage(Integer tage) { this.tage = tage; } public Date getTcreateDate() { return tcreateDate; } public void setTcreateDate(Date tcreateDate) { this.tcreateDate = tcreateDate; } public List<Student> getStudents() { return students; } public void setStudents(List<Student> students) { this.students = students; } } [/code] Student model [code="java"] import java.util.ArrayList; import java.util.Date; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.SequenceGenerator; import javax.persistence.Table; @Entity @Table(name = "Student") public class Student implements java.io.Serializable{ /** * */ private static final long serialVersionUID = 1L; @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="S_Student") @SequenceGenerator(name="S_Student", allocationSize=1, initialValue=1,sequenceName="S_Student") private Long sid; private String sname; private Integer sage; private Date screateDate; @ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY, targetEntity = Teacher.class) @JoinTable(name = "RS_Teacher_Student", joinColumns = { @JoinColumn(name = "sid")}, inverseJoinColumns = { @JoinColumn(name = "tid") }) private List<Teacher> teachers=new ArrayList<Teacher>(); public Long getSid() { return sid; } public void setSid(Long sid) { this.sid = sid; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } public Integer getSage() { return sage; } public void setSage(Integer sage) { this.sage = sage; } public Date getScreateDate() { return screateDate; } public void setScreateDate(Date screateDate) { this.screateDate = screateDate; } public List<Teacher> getTeachers() { return teachers; } public void setTeachers(List<Teacher> teachers) { this.teachers = teachers; } } [/code] TeacherDAO [code="java"] import org.springframework.orm.hibernate3.support.HibernateDaoSupport; public class TeacherDAO extends HibernateDaoSupport { public void insertTeacher(Teacher t){ getHibernateTemplate().saveOrUpdate(t); } } [/code] StudentDAO [code="java"] import org.springframework.orm.hibernate3.support.HibernateDaoSupport; public class StudentDAO extends HibernateDaoSupport { public void insertStudent(Student s){ getHibernateTemplate().saveOrUpdate(s); } } [/code] 测试程序 [code="java"] import java.util.Date; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestOracle { private ApplicationContext context; private TeacherDAO tdao; private StudentDAO sdao; public TestOracle() { context = new ClassPathXmlApplicationContext( new String[] { "application_oracle.xml" }); tdao=(TeacherDAO)context.getBean("TeacherDAO"); sdao=(StudentDAO)context.getBean("StudentDAO"); } public void save(){ Teacher t=new Teacher(); t.setTname("baiyj"); t.setTage(Integer.valueOf("23")); t.setTcreateDate(new Date()); Student s1=new Student(); s1.setSname("t11"); s1.setSage(Integer.valueOf("21")); s1.setScreateDate(new Date()); Student s2=new Student(); s2.setSname("t12"); s2.setSage(Integer.valueOf("22")); s2.setScreateDate(new Date()); s1.getTeachers().add(t); s2.getTeachers().add(t); tdao.insertTeacher(t); sdao.insertStudent(s1); sdao.insertStudent(s2); } /** * @param args */ public static void main(String[] args) { TestOracle to=new TestOracle(); to.save(); } } [/code] spring配置文件application_oracle.xml [code="xml"] <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" /> <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:TEST" /> <property name="username" value="sa" /> <property name="password" value="123456" /> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"> <property name="dataSource"> <ref bean="dataSource"/> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop> <prop key="hibernate.show_sql">true</prop> </props> </property> <property name="annotatedClasses"> <list> <value>com.test.oracle.Teacher</value> <value>com.test.oracle.Student</value> </list> </property> </bean> <!--Hibernate TransactionManager--> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <bean id="TeacherDAO" class="com.test.oracle.TeacherDAO"> <property name="sessionFactory" ref="sessionFactory" /> </bean> <bean id="StudentDAO" class="com.test.oracle.StudentDAO"> <property name="sessionFactory" ref="sessionFactory" /> </bean> [/code] 现在的问题就是：执行完TestOracle后，数据库中可以保存成功，但是student和teacher表里面的主键id都和他们之间的关联表里的id分别都对应不上，比如student里面有两条记录，他们id分别是2，4；teacher表里面也有id为2的记录，但是在他们的关系表中却成了teacher是1，student是1，3了，请问是那里配置的不对吗？另外关系表里面没有强制设置外键关联，原来设置了外键关联，但保存报错，说是“违反完整约束条件,未找到父项关键字”，现在去掉关联，但出现上面这种情况，主键id总是“错位”，真不知道是怎么回事。 [b]问题补充：[/b] 我用的是序列啊，是自增的。怎么序列不能自增吗？ [b]问题补充：[/b] 我将教师对学生的关系改成一对多的关联关系，结果也是一样的，比如：teacher表里面的主键id是4，而student表里面的tid都是3，总是差那么一拍。

在使用ejb开发的过程中，莫名奇妙的出现如下错误。 Caused by: org.hibernate.PropertyNotFoundException: Could not find a setter for property pk in class org.oecp.core.domain.permission.UserEntity at org.hibernate.property.BasicPropertyAccessor.createSetter(BasicPropertyAccessor.java:240) at org.hibernate.property.BasicPropertyAccessor.getSetter(BasicPropertyAccessor.java:233) at org.hibernate.mapping.Property.getSetter(Property.java:299) at org.hibernate.tuple.entity.PojoEntityTuplizer.buildPropertySetter(PojoEntityTuplizer.java:272) at org.hibernate.tuple.entity.AbstractEntityTuplizer.<init>(AbstractEntityTuplizer.java:149) at org.hibernate.tuple.entity.PojoEntityTuplizer.<init>(PojoEntityTuplizer.java:76) at org.hibernate.tuple.entity.EntityEntityModeToTuplizerMapping.<init>(EntityEntityModeToTuplizerMapping.java:80) at org.hibernate.tuple.entity.EntityMetamodel.<init>(EntityMetamodel.java:325) at org.hibernate.persister.entity.AbstractEntityPersister.<init>(AbstractEntityPersister.java:457) at org.hibernate.persister.entity.SingleTableEntityPersister.<init>(SingleTableEntityPersister.java:131) at org.hibernate.persister.PersisterFactory.createClassPersister(PersisterFactory.java:84) at org.hibernate.impl.SessionFactoryImpl.<init>(SessionFactoryImpl.java:261) at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1327) at org.hibernate.cfg.AnnotationConfiguration.buildSessionFactory(AnnotationConfiguration.java:867) at org.hibernate.ejb.Ejb3Configuration.buildEntityManagerFactory(Ejb3Configuration.java:669) ... 50 more UserEntity: @Entity @Table(name = "t_c_user") public class UserEntity extends BaseEntityBean { private Integer userId; private String userName; private String password; @Id @Column(name = "user_id") @GeneratedValue(strategy = GenerationType.TABLE) public Integer getUserId() { return userId; } public void setUserId(Integer userId) { this.userId = userId; } @Column(name = "user_name") public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } @Column public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } } BaseEntityBean: @MappedSuperclass public abstract class BaseEntityBean implements Serializable { private static final long serialVersionUID = 1962905939086138888L; /** 更新时间 **/ @Temporal(value=TemporalType.TIMESTAMP) private Date updateTime; /** 是否删除 **/ private boolean deleted; @Embedded public EditState editstate ; @Column(name = "update_time") public Date getUpdateTime() { return updateTime; } public void setUpdateTime(Date updateTime) { this.updateTime = updateTime; } @Column(name = "deleted") public boolean isDeleted() { return deleted; } public void setDeleted(boolean deleted) { this.deleted = deleted; } private BaseEntityBeanUtility givemeBeanUtility(){ return new BaseEntityBeanUtility(this); } @Override public String toString() { return givemeBeanUtility().beanToString(); } @Override public boolean equals(Object obj) { return givemeBeanUtility().equalsBean(obj); } @Override public int hashCode() { return givemeBeanUtility().hashCodeBean(); } @Override protected Object clone() throws CloneNotSupportedException { Object obj = null; try { obj = givemeBeanUtility().cloneBean(); } catch (Exception e) { throw new CloneNotSupportedException(StackTraceUtil.getStackTrace(e)); } return obj; } public Object getAttributeValue(String attributeName){ return givemeBeanUtility().getAttributeVlaue(attributeName); } /** * 获取主键值 * TODO 此方法应为抽象方法，由子类覆盖。为调试代码暂时不做抽象。以后修改为抽象方法，各子类应自己实现。 * @author slx * @date 2009-6-12 上午09:15:11 * @modifyNote * @return */ @Enumerated public String myPk(){ return "返回主键值"; } } 才开始在BaseEntityBean中有个getPk()方法，以为是这里的错误，后来加上@Enumerated注解还是不行，再后来将getPk()改为myPk()，还是不行。 最后将UserEntity中的@Id注解，由getUserId()转移到属性userId上面，结果服务器就能正常运行了。实在搞不明白这是为什么？ 注解是可以加在getter方法上的啊，哪位高人给小弟指点一二。

我希望删除user的时候，把cmscompany给级联删除掉。以下是我的代码，两实体是基于主键的一对一关系，级联删除一直删除不了，找了 很多资料，都没办法。求大神们帮帮忙 ``` //User实体 import java.io.Serializable; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToOne; import javax.persistence.Table; @Entity @Table(name="user") public class User implements Serializable{ /** * */ private static final long serialVersionUID = 1L; private Integer id; private String name; private CmsUserCompany cmsUserCompany; @Id @GeneratedValue(strategy=GenerationType.AUTO) public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @Column public String getName() { return name; } public void setName(String name) { this.name = name; } @OneToOne(fetch = FetchType.LAZY, cascade = { CascadeType.ALL },mappedBy="user") public CmsUserCompany getCmsUserCompany() { return cmsUserCompany; } public void setCmsUserCompany(CmsUserCompany cmsUserCompany) { this.cmsUserCompany = cmsUserCompany; } } ``` ``` import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.MapsId; import javax.persistence.OneToOne; import javax.persistence.Table; @Entity @Table(name="CmsUserCompany") public class CmsUserCompany implements Serializable{ /** * */ private static final long serialVersionUID = 1L; private Integer id; private String name; private User user; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @Column public String getName() { return name; } public void setName(String name) { this.name = name; } @MapsId @OneToOne @JoinColumn(name="userid") public User getUser() { return user; } public void setUser(User user) { this.user = user; } } ```

用myeclipse实现的反向生成实体类，然后想用注解序列的形式实现id自增，可是每次插入数据库的id都会以50增长，问题是我的序列是设置的按1增长，而且每次插入以后序列的下一个还是原来的数，说明序列没用到吧，我是用 @SequenceGenerator(name="SEQ_GEN", sequenceName="YIXING_USER$SEQ") @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_GEN")的方式来注解的，有没有人遇到过同样的问题

第一次到javaeye社区发帖提问，这社区真的不错，还请大家多多指教。 进入正题,问题一，班级和学生是一对多的关系，自己已经通过JPA注解实现了它们的一对多关系，并且生成数据库表也是正确的。tab_student表有三个字段，student_id(主键),student_name,banji_id(外键)，而tab_banji表中有banji_id(主键)和banji_name两个字段，我现在的想法是实现插入学生到某个班去，请问怎样才能实现？ 还有一个问题，就是我通过注解设置的主键生成策略是auto类型的话，自己不能定义主键值吗？举个例子，现在有个tab_teacher表，它有2个字段,分别是teacher_id和teacher_name，现在我用persist(new Teacher(1,"王老师"))这样插入报错，但是我在实体中加个只有teacher_name属性的构造方法，也就是用persist(new Teacher("王老师"))是可以实现插入的，到数据库表中看到主键是自动增长的。请问大家怎样才能自己定义主键值啊？谢谢大家不吝赐教了。

1.有实体类Student ``` public class Student { //id为主键 private String id; private String passwd; private String name; private String sex; private String school; private String major; private String stuClass; //省略了无参构造，getter/setter等方法 ``` 2.有实体类Subject ``` public class Subject { //id为主键 private Integer id; private Exam exam; private String question; private String answer; private int score; //省略了无参构造，getter/setter等方法 ``` 3.有实体类AnswerSubject ``` public class AnswerExam { //使用Sstudent的id和Subject的id作为联合主键 private Student student; private Subject subject; private String stuAnswer; ///省略了无参构造，getter/setter等方法 ``` 4.请问，在AnswerSubject.hbm.xml该怎么配置联合主键？已知知识如下： <hibernate-mapping> <class name="com.abc.entities.AnswerExam" table="ANSWEREXAM"> <!-- 配置联合主键 --> <composite-id name="id"> <key-property name="student" type="com.abc.entities.Student"> <column name="STUDENT" not-null="true"> </column> </key-property> <key-property name="subject" type="com.abc.entities.Subject"> <column name="SUBJECT" not-null="true"> </column> </key-property> </composite-id> <property name="stuAnswer" type="java.lang.String"> <column name="STUANSWER" /> </property> </class> </hibernate-mapping>

我现在有3张表，分别是角色表，权限表，模块表。我现在要创建一张额外表。把它们3个表的主键都引入进来。 用jpa的注解应该怎么写呢？

## 有关于 JPA 和 Mybatis Plus的问题 问题背景描述 1. 确定数据库字段和其所对应的实体类字段一致。例如：DB（mem_name）,Class(memName) 2. 用于数据库操作的表，以下简称A表。A表中主键id，名称是id，类型varchar，不为NULL。 3. 我实体类定义如下： ``` // A就是A表对应的实体类 @Data @TableName("A") public class A extends BaseClass { ......... } @Data public abstract class BaseEntity { @TableId(value = "id") private String id ;//id在application.yml中是UUID的 ....... } ``` 问题： 1. 当使用 Mybatis Plus时： 1.1 利用SQL注解，BaseMapper.selectByID,通过Mapper.XML进行查询一行记录，在ServiceImpl的Test测试方法中可以查询出我需要的记录，而通过Controller进行调用Service方法来获取记录，但是SQL已经执行了。就无法查出，但是新增是可以向A表进行插入数据。 为什么通过Controller调用Service的方法，方面内部：selectByID或以上3中方式之一，就无法查询出数据. 2. 当使用 JPA 时： ``` // A就是A表对应的实体类 @Data @Entity @TableName("A") public class A extends BaseClass { @Id @TableId(value = "id") private String id ; ......... } @Data public abstract class BaseEntity { ....... } ``` 2.1 你看的没错，我就是把注解放到原有的MyBatis Plus上面，但是调整id位置了，我放到A类中，同样，可以测试查询，放到tomcat中，就无法用请求->controller->service->repository来查询所需数据？ MyBatis-Plus：selectById()无法查询 JAP：findOne(id) 无法查询 都无法放到tomcat中，用请求的方式进行查询，测试都能过！ 不明白。求赐教！

如题，还请各位告知，不胜感激.................... 谢谢了

源实体中使用@JoinColumn指定外键（为参考实体的主键）： ``` @ManyToOne(cascade={CascadeType.REFRESH,CascadeType.DETACH}, optional=true, fetch = FetchType.LAZY) @JoinColumn(name="DD_TYPE_ID") private FieldDropdownType type; ``` 参考的FieldDropdownType 实体的主键： ``` @Id @Column(name="DD_TYPE_ID") @GeneratedValue(strategy = GenerationType.AUTO) private Long ddTypeId; ``` 问题： 浏览器端传递的json部分如下： ``` { "id": 10, ..., "type": { "ddTypeId": 1 }, ... } ``` 这是插入一条源实体的数据记录，id为源实体的主键值，type为@JoinColumn注解的属性，参考实体中存在ddTypeId为1的列。但请求时，服务端提示： ``` **[RMI TCP Connection(4)-192.168.2.37] WARN org.hibernate.util.JDBCExceptionReporter - SQL Error: 1048, SQLState: 23000 [RMI TCP Connection(4)-192.168.2.37] ERROR org.hibernate.util.JDBCExceptionReporter - Column 'DD_TYPE_ID' cannot be null javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: could not insert: ** ``` 即DD_TYPE_ID列不能为空，但不是通过type属性传递了吗？如果不是这样传递，外键列的值应该是怎么设置的？

有两个类：Survey和Questions，问卷类和题目类，它们是多对多的关系，即：一张试卷可以有多个题目，一个题目可以属于多个试卷，我用两个一对多，数据库用中间表来实现，并有第三个类SurveyQuestions. surveuy类如下： [code="java"]//问卷实体：包括各种属性 @Entity @Table(name="_survey") public class Survey { private int id;// 问卷ID private String name;// 问卷标题 private String des;// 问卷描述或者备注 private boolean state;// 状态：是否开放 private SurveyType surveyType;// 问卷类型 private int count;// 问卷数量限制 private Date createTime;// 问卷创建时间 private Date publishTime;// 问卷发布时间 private Date deadline;// 问卷截止提交日期 private String password;// 问卷访问密码 private boolean grade;//是否是打分问卷 @Id @GeneratedValue public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDes() { return des; } public void setDes(String des) { this.des = des; } public boolean isState() { return state; } public void setState(boolean state) { this.state = state; } @ManyToOne @JoinColumn(name = "type_id") public SurveyType getSurveyType() { return surveyType; } public void setSurveyType(SurveyType surveyType) { this.surveyType = surveyType; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } public Date getCreateTime() { return createTime; } public void setCreateTime(Date createTime) { this.createTime = createTime; } public Date getPublishTime() { return publishTime; } public void setPublishTime(Date publishTime) { this.publishTime = publishTime; } public Date getDeadline() { return deadline; } public void setDeadline(Date deadline) { this.deadline = deadline; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public boolean isGrade() { return grade; } public void setGrade(boolean grade) { this.grade = grade; }[/code] questions类 [code="java"]<span></span> @Entity @Table(name="_questions") public class Questions { private int id;// 问题主键ID private QuestionType questionType;// 问题类型 private String head;// 问题题目 private String body;// 问题主体 private String answer;// 预留字段，如果是网上答卷，则是答案 private String remarks;// 预留字段，备注 private int number;// 选项个数 @Id @GeneratedValue public int getId() { return id; } public void setId(int id) { this.id = id; } public String getHead() { return head; } public void setHead(String head) { this.head = head; } public String getBody() { return body; } public void setBody(String body) { this.body = body; } public String getAnswer() { return answer; } public void setAnswer(String answer) { this.answer = answer; } public String getRemarks() { return remarks; } public void setRemarks(String remarks) { this.remarks = remarks; } @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name = "type_id") public QuestionType getQuestionType() { return questionType; } public void setQuestionType(QuestionType questionType) { this.questionType = questionType; } @Column(nullable = true) public int getNumber() { return number; } public void setNumber(int number) { this.number = number; } }[/code] surveyQuestion类 [code="java"]package com.questionnaire.model; import java.util.Date; import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.OneToMany; import javax.persistence.Table; @Entity @Table(name = "_surveyquestion") public class SurveyQuestion { private int id;// 问卷题库关联表ID，主键 private Survey survey;// 对应问卷ID，外键 private Questions questions;// 对应题目ID，外键 private int number;// 题号，即该题目在本问卷的题号 @Id @GeneratedValue public int getId() { return id; } public void setId(int id) { this.id = id; } this.userIp = userIp; public int getNumber() { return number; } public void setNumber(int number) { this.number = number; } @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = "survey_id") public Survey getSurvey() { return survey; } public void setSurvey(Survey survey) { this.survey = survey; } @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = "questions_id") public Questions getQuestions() { return questions; } public void setQuestions(Questions questions) { this.questions = questions; } }[/code] 我想实现删除题目时删除_questions表里的数据，同时删除_surveyQuestion表里的数据。当然survey同样？怎样实现呢？

result returns more than one elements 单看结果是 数据库还是插入了2条数据了 但是这个异常该怎么解决啊 我的标题 有点歧义 但是你们看下代码 应该能看出来 这个"同一个对象”实际上是通过new的方法创建的 也就是说2次都没有主键 所以不存在对一个持久化对象 save ``` ``` public void save(Task task){ if(task.getId()==null){ task.setCreateTime(new Date()); } taskRepository.saveAndFlush(task); } ``` StudentPosition sp=spService.getOne(id); Student student=sp.getStudent(); Position position=sp.getPosition(); Task task=new Task(); task.setStudent(student); task.setPosition(position); //保存任务 taskService.save(task); ```

用户表除了ID为主键还需要用户名字段唯一且不能为空。请问该怎么做。貌似联合主键是允许其中单个字段重复的。用annotation怎么设置呢？请详细说明。

<div class="iteye-blog-content-contain" style="font-size: 14px;"> <p>项目是ssh三大框架的，数据库是通过实体对象PO用注解的方式生成的。现在有两个PO实体，一个是角色，一个是菜单。他们之间是多对多关系，数据库会生成一张中间的关联表（仅包含ROEL_ID和TREE_ID），现在我想做权限分配，就是实现根据角色分配菜单的功能。在RoleAction这边想通过roleService.getRole(id).getTrees()的方式得到该角色下相应的菜单，但总是报如下错误：</p> <p><span style="color: #ff0000;">org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: wteam.pojo.RolePO.trees, no session or session was closed</span></p> <p><span style="color: #000000;">类RolePO和TreePO如下，Role是维护端，网上很多说多对多用懒加载的方式比较好，但是报错说session关闭了我又取不到结果。我如果换成急加载的方式，是能得到该RoleI下的Tree表了，但是查询Role表就出现问题了，记录会变成很多条，而且还是重复的。就是不知道哪里出了问题</span></p> <p> </p> <pre name="code" class="java">public class RolePO implements Serializable{ @Entity @Table(name="sys_role") public class RolePO implements Serializable{ //角色PO private static final long serialVersionUID = -6889909565150942238L; @Id @GeneratedValue(strategy=GenerationType.AUTO) @Column(name = "ROLE_ID") private int roleId; //角色标识位 @Column(name = "NAME",unique = true,nullable = false) private String name; //角色名称 @Column(name = "DISCRIPTION") private String discription; //角色描述 @ManyToMany(targetEntity = TreePO.class, cascade = CascadeType.REFRESH) @JoinTable(name = "sys_role_tree_menu", joinColumns = { @JoinColumn(name = "ROLE_ID")}, inverseJoinColumns = { @JoinColumn(name = "TREE_ID") }) private List&lt;TreePO&gt; trees; //省略set、get方法 } </pre> <p> </p> <pre name="code" class="java">@Entity @Table(name="sys_tree_menu") public class TreePO implements Serializable{ private static final long serialVersionUID = -1549993655782216421L; //菜单PO @Id @GeneratedValue(strategy=GenerationType.AUTO) @Column(name = "TREE_ID") private int treeId; //树形导航标识位 @Column(name = "NAME",unique = true,nullable = false) private String name; //名称 @ManyToMany(cascade = CascadeType.MERGE,mappedBy = "trees") private List&lt;RolePO&gt; roles; //省略其他属性、set()、get()... } </pre> <p> </p> <p> </p> </div>

今年，我也32了 ，为了不给大家误导，咨询了猎头、圈内好友，以及年过35岁的几位老程序员……舍了老脸去揭人家伤疤……希望能给大家以帮助，记得帮我点赞哦。 目录： 你以为的人生 一次又一次的伤害 猎头界的真相 如何应对互联网行业的「中年危机」 一、你以为的人生 刚入行时，拿着傲人的工资，想着好好干，以为我们的人生是这样的： 等真到了那一天，你会发现，你的人生很可能是这样的： ...

程序员在一个周末的时间，得了重病，差点当场去世，还好及时挽救回来了。

数据结构与算法思维导图

老生常谈的一个梗，到2020了还在争论，你们一天天的，哎哎哎，我不是针对你一个，我是说在座的各位都是人才！ 上图红色的这3个箭头，对于通过new产生一个字符串（”宜春”）时，会先去常量池中查找是否已经有了”宜春”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。 也就是说准确答案是产生了一个或两个对象，如果常量池中原来没有 ”宜春” ,就是两个。...

昨天早上通过远程的方式 review 了两名新来同事的代码，大部分代码都写得很漂亮，严谨的同时注释也很到位，这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时，还是忍不住破口大骂：“我擦，小王，你丫写的 switch 语句也太老土了吧！” 来看看小王写的代码吧，看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

文章目录Linux 概述什么是LinuxUnix和Linux有什么区别？什么是 Linux 内核？Linux的基本组件是什么？Linux 的体系结构BASH和DOS之间的基本区别是什么？Linux 开机启动过程？Linux系统缺省的运行级别？Linux 使用的进程间通信方式？Linux 有哪些系统日志文件？Linux系统安装多个桌面环境有帮助吗？什么是交换空间？什么是root帐户什么是LILO？什...

一、背景 在开发联调阶段发现一个接口的响应时间特别长，经常超时，囧… 本文讲讲是如何定位到性能瓶颈以及修改的思路，将该接口从 2 s 左右优化到 200ms 以内 。 二、步骤 2.1 定位 定位性能瓶颈有两个思路，一个是通过工具去监控，一个是通过经验去猜想。 2.1.1 工具监控 就工具而言，推荐使用 arthas ，用到的是 trace 命令 具体安装步骤很简单，大家自行研究。 我的使用步骤是...

微信上收到一位读者小涛的留言，大致的意思是自己只有高中学历，经过培训后找到了一份工作，但很难胜任，考虑要不要辞职找一份他能力可以胜任的实习工作。下面是他留言的一部分内容： 二哥，我是 2016 年高中毕业的，考上了大学但没去成，主要是因为当时家里经济条件不太允许。 打工了三年后想学一门技术，就去培训了。培训的学校比较垃圾，现在非常后悔没去正规一点的机构培训。 去年 11 月份来北京找到了一份工...

JVM内存结构和Java内存模型都是面试的热点问题，名字看感觉都差不多，网上有些博客也都把这两个概念混着用，实际上他们之间差别还是挺大的。 通俗点说，JVM内存结构是与JVM的内部存储结构相关，而Java内存模型是与多线程编程相关，本文针对这两个总是被混用的概念展开讲解。 JVM内存结构 JVM构成 说到JVM内存结构，就不会只是说内存结构的5个分区，而是会延展到整个JVM相关的问题，所以先了解下

互联网公司工作，很难避免不和黑客们打交道，我呆过的两家互联网公司，几乎每月每天每分钟都有黑客在公司网站上扫描。有的是寻找 Sql 注入的缺口，有的是寻找线上服务器可能存在的漏洞，大部分都...

浏览器再现“神仙打架”。整理 | 屠敏头图 | CSDN 下载自东方 IC出品 | CSDN（ID：CSDNnews）从 IE 到 Chrome，再从 Chrome 到 Edge，微软与...

loonggg读完需要3分钟速读仅需 1 分钟大家好，我是你们的校长。我之前讲过，这年头，只要肯动脑，肯行动，程序员凭借自己的技术，赚钱的方式还是有很多种的。仅仅靠在公司出卖自己的劳动时...

最近有个老铁，告诉我说，上班一个月，后悔当初着急入职现在公司了。他之前在美图做手机研发，今年美图那边今年也有一波组织优化调整，他是其中一个，在协商离职后，当时捉急找工作上班，因为有房贷供着，不能没有收入来源。所以匆忙选了一家公司，实际上是一个大型外包公司，主要派遣给其他手机厂商做外包项目。**当时承诺待遇还不错，所以就立马入职去上班了。但是后面入职后，发现薪酬待遇这块并不是HR所说那样，那个HR自...

昨天看到一档综艺节目，讨论了两个话题：（1）中国学生的数学成绩，平均下来看，会比国外好？为什么？（2）男生的数学成绩，平均下来看，会比女生好？为什么？同时，我又联想到了一个技术圈经常讨...

故事总是一个接着一个到来...上周写完《鲁大师已经彻底沦为一款垃圾流氓软件！》这篇文章之后，鲁大师的市场工作人员就找到了我，希望把这篇文章删除掉。经过一番沟通我先把这篇文章从公号中删除了...

蒋凡是何许人也？ 2017年12月27日，在入职4年时间里，蒋凡开挂般坐上了淘宝总裁位置。 为此，时任阿里CEO张勇在任命书中力赞： 蒋凡加入阿里，始终保持创业者的冲劲，有敏锐的...

原博客再更新，可能就没了，之后将持续更新本篇博客。

提到“程序员”，多数人脑海里首先想到的大约是：为人木讷、薪水超高、工作枯燥…… 然而，当离开工作岗位，撕去层层标签，脱下“程序员”这身外套，有的人生动又有趣，马上展现出了完全不同的A/B面人生！ 不论是简单的爱好，还是正经的副业，他们都干得同样出色。偶尔，还能和程序员的特质结合，产生奇妙的“化学反应”。 @Charlotte：平日素颜示人，周末美妆博主 大家都以为程序媛也个个不修边幅，但我们也许...

文章目录数据库基础知识为什么要使用数据库什么是SQL？什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式？分别有什么区别？数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别？InnoDB引擎的4大特性存储引擎选择索引什么是索引？索引有哪些优缺点？索引使用场景（重点）...

有个好朋友ZS，是技术总监，昨天问我：“有一个老下属，跟了我很多年，做事勤勤恳恳，主动性也很好。但随着公司的发展，他的进步速度，跟不上团队的步伐了，有点...

私下里，有不少读者问我：“二哥，如何才能写出一份专业的技术简历呢？我总感觉自己写的简历太烂了，所以投了无数份，都石沉大海了。”说实话，我自己好多年没有写过简历了，但我认识的一个同行，他在阿里，给我说了一些他当年写简历的方法论，我感觉太牛逼了，实在是忍不住，就分享了出来，希望能够帮助到你。 01、简历的本质 作为简历的撰写者，你必须要搞清楚一点，简历的本质是什么，它就是为了来销售你的价值主张的。往深...

有小伙伴问松哥这个问题，他在上海某公司，在离职了几个月后，前公司的领导联系到他，希望他能够返聘回去，他很纠结要不要回去？ 俗话说好马不吃回头草，但是这个小伙伴既然感到纠结了，我觉得至少说明了两个问题：1.曾经的公司还不错；2.现在的日子也不是很如意。否则应该就不会纠结了。 老实说，松哥之前也有过类似的经历，今天就来和小伙伴们聊聊回头草到底吃不吃。 首先一个基本观点，就是离职了也没必要和老东家弄的苦...

往往，我们看不进去大段大段的逻辑。深刻的哲理，往往短而精悍，一阵见血。问：产品经理挺漂亮的，有点心动，但不知道合不合得来。男生更看重女生的身材脸蛋，还是...

都是出来打工的，多为自己着想

本文作者用对比非常鲜明的两个开发团队的故事，讲解了敏捷开发之道 —— 如果你的团队缺乏统一标准的环境，那么即使勤劳努力，不仅会极其耗时而且成果甚微，使用...

二哥，有个事想询问下您的意见，您觉得应届生值得去外包吗？公司虽然挺大的，中xx，但待遇感觉挺低，马上要报到，挺纠结的。

当HR压你价，说你只值7K时，你可以流畅地回答，记住，是流畅，不能犹豫。 礼貌地说：“7K是吗？了解了。嗯~其实我对贵司的面试官印象很好。只不过，现在我的手头上已经有一份11K的offer。来面试，主要也是自己对贵司挺有兴趣的，所以过来看看……”（未完） 这段话主要是陪HR互诈的同时，从公司兴趣，公司职员印象上，都给予对方正面的肯定，既能提升HR的好感度，又能让谈判气氛融洽，为后面的发挥留足空间。...

HashMap底层实现原理，红黑树，B+树，B树的结构原理 Spring的AOP和IOC是什么？它们常见的使用场景有哪些？Spring事务，事务的属性，传播行为，数据库隔离级别 Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringMVC的工作原理，SpringBoot框架的优点，MyBatis框架的优点 SpringCould组件有哪些，他们...

面试阿里p7被问到的问题(当时我只知道第一个)：@Conditional是做什么的?@Conditional多个条件是什么逻辑关系？条件判断在什么时候执...

终于懂了TCP和UDP协议区别

编程语言层出不穷，从最初的机器语言到如今2500种以上的高级语言，程序员们大呼“学到头秃”。程序员一边面临编程语言不断推陈出新，一边面临由于许多代码已存在，程序员编写新应用程序时存在重复“搬砖”的现象。 无代码/低代码编程应运而生。无代码/低代码是一种创建应用的方法，它可以让开发者使用最少的编码知识来快速开发应用程序。开发者通过图形界面中，可视化建模来组装和配置应用程序。这样一来，开发者直...

最近面试了一个31岁8年经验的程序猿，让我有点感慨，大龄程序猿该何去何从。