transient

I have JPA entities where some properties are annotated with @Transient . Should I use these properties in equals/hashCode/toString methods? My first thought is NO but I don't know why. Tips? Ideas? Explanations? Pascal Thivent The case of toString() is different, you can do whatever you want with toString() so I will only cover equals() (and hashCode() ). First, the rule: if you want to store an object in a List , Map or a Set then it is a requirement that equals and hashCode are implemented so they obey the standard contract as specified in the documentation . Now, how to implement equals()

I have a problem on Scala. I serialize an instance of class with @transient lazy val field. And then I deserialize it, the field is assigned null . I expect the lazy evaluation after deserialization. What should I do? Following is a sample code. object Test { def main(args: Array[String]){ //---------------- // ClassA - with @transient //---------------- val objA1 = ClassA("world"); println(objA1); // This works as expected as follows: // "Good morning." // "Hello, world" saveObject("testA.dat", objA1); val objA2 = loadObject("testA.dat").asInstanceOf[ClassA]; println(objA2); // I expect this

Currently I'm learning the Spring framework, mainly focusing on it's Security Module. I've watched some guides in connection with registration and login. I saw this common usage of transient keyword or @Transient annotation on the password field in the User class. My dummy app is using Spring Boot + Spring MVC + Spring Security + MySQL. I know that Java's transient keyword is used to denote that a field is not to be serialized. JPA's @Transient annotation ... ...specifies that the property or field is not persistent . It is used to annotate a property or field of an entity class, mapped

Working on spark, sometimes I need to send a non-serializable object in each task. A common pattern is @transient lazy val , e.g class A(val a: Int) def compute(rdd: RDD[Int]) = { // lazy val instance = { @transient lazy val instance = { println("in lazy object") new A(1) } val res = rdd.map(instance.a + _).count() println(res) } compute(sc.makeRDD(1 to 100, 8)) I found that @transient is not necessary here. lazy val can already create the non-serializable upon each task is executed. But people suggest using @transient . What is the advantage, if we set @transient on the non-initialized lazy

I am serializing a POJO into JSON using Jackson 2.1.4 but I want to ignore a particular field from getting serialized. I used transient but still it is serializing that element. public class TestElement { int x; private transient String y; public int getX() { return x; } public void setX(int x) { this.x = x; } public String getY() { return y; } public void setY(String y) { this.y = y; } } I am serializing as following: public static void main(String[] args) throws JsonProcessingException { TestElement testElement = new TestElement(); testElement.setX(10); testElement.setY("adasd");

I read the documentation on transient properties but I can't really understand their purpose. Can someone tell me the difference between having and not having a transient property if I have a custom subclass of NSManagedObject like this? @interface Board : NSManagedObject { NSMutableArray *_grid; } // Core Data to-many relationship @property (nonatomic, retain) NSSet *pieces; @property (nonatomic, readonly) NSArray *grid; -(void)awake; -(void)movePiece:(PieceState *)piece to_x:(int)x y:(int)y; @end @implementation Board @dynamic pieces; -(void)awakeFromInsert { [super awakeFromInsert]; [self

I just found out in Java you can declare a field 'static transient' - the compiler doesn't complain. This doesn't seem to be useful in any way since static fields are not serialized, as we all know. But I wonder, is there actually a case where 'static transient' fields are useful? Nope - you said it yourself, static fields aren't serialized. Kinda weird that the compiler lets you do that though. MC Emperor In most cases, it is not useful. Static fields are indeed not serialized by the default serializer. However, static transient fields can be detected via reflection. If someone writes its own

I am working on an NHibernate project and have a question regarding updating transient entities. Basically the workflow is as follows: Create a DTO (projection) and send over the wire to client. This has a small subset of properties from the entity. Client sends back the changed DTO Map the DTO properties back onto the appropriate enitity so an UPDATE statement can be generated and executed by NH. Save the entity Point 4 is where I have the issue. Currently I can achieve this update using the session.Merge() method, however it must first load the entity from the db (assume no 2LC) before

I am using hibernate 4.1.9. My code is @Transient private String ldapIdTemp; package is import javax.persistence.Transient; Still in hibernate query, it is not working and putting the attribute in the query. part of query snippet (assetasset0_.ldapIdTemp as ldapIdTemp16_0_, ) I am not sure what I am doing wrong. Can you try creating setter and getter for the field and annotate the get method with @Transient , as follows: private String ldapIdTemp; @Transient public String getLdapIdTemp() { return ldapIdTemp; } public void setLdapIdTemp(String ldapIdTemp) { this.ldapIdTemp = ldapIdTemp; }