प्ले के साथ जेएसओएन प्रस्तुत करना! और स्कैला

Question

मेरे पास स्कैला क्लास से JSON ऑब्जेक्ट को प्रस्तुत करने के संबंध में एक साधारण प्रश्न है। मुझे deserializer (पढ़ने, लिखने) लागू करने के लिए क्यों है।

मैं निम्नलिखित मामले वर्ग है:

case class User(firstname:String, lastname:String, age:Int) 

और मेरे नियंत्रक में:

val milo:User = new User("Sam","Fisher",23); 

Json.toJson(milo); 

मैं संकलन त्रुटि मिलती है: नहीं Json deserializer प्रकार models.User के लिए मिल गया। इस प्रकार के लिए एक अंतर्निहित लेखन या प्रारूप को लागू करने का प्रयास करें।

मेरी पिछली परियोजना में मुझे कक्षा में एक पाठक, लेखक वस्तु को काम करने के लिए इसे लागू करना पड़ा और मुझे यह बहुत परेशान लगता है।

object UserWebsite { 
    implicit object UserWebsiteReads extends Format[UserWebsite] { 

    def reads(json: JsValue) = UserWebsite(
     (json \ "email").as[String], 
     (json \ "url").as[String], 
     (json \ "imageurl").as[String]) 

    def writes(ts: UserWebsite) = JsObject(Seq(
     "email" -> JsString(ts.email), 
     "url" -> JsString(ts.url), 
     "imageurl" -> JsString(ts.imageurl))) 
    } 
} 

Answer 1

क्या आप खेलने 2.0.x उपयोग कर रहे हैं कर सकते हैं

import com.codahale.jerkson.Json._ 

generate(milo) 

उत्पन्न यह करने के लिए प्रतिबिंब का उपयोग करता है।

खेल 2.1 में आप उस अंतर्निहित वस्तु के लिए मैक्रो बनाने के लिए जेसन.writes का उपयोग कर सकते हैं। कोई रनटाइम प्रतिबिंब की आवश्यकता नहीं है!

import play.api.libs.json._ 
import play.api.libs.functional.syntax._ 

implicit val userWrites = Json.writes[User] 
Json.toJson(milo) 

Answer 2

मैं वास्तव में 2.1-RC1 खेलने के लिए उन्नत करने के लिए सलाह देते हैं यहाँ क्योंकि, JSON लेखकों/पाठकों बहुत ही सरल से परिभाषित करने की (अधिक जानकारी के here)

लेकिन आपको कुछ त्रुटियों से बचने में मदद करने के लिए कर रहे हैं, मैं आपको आयात के साथ एक संकेत दूंगा: - केवल इन आयातों का उपयोग करें! (ध्यान दें कि json.Reads शामिल नहीं है)

import play.api.libs.json._ 
import play.api.libs.functional.syntax._ 
import play.api.libs.json.Writes._ 

और आप केवल लिखने के लिए इस कोड/लिखने Json से/अपनी कक्षा में पढ़ने के लिए (बेशक आप User बजाय Address होगा:

implicit val addressWrites = Json.writes[Address] 
implicit val addressReads = Json.reads[Address] 

अब, वे स्वचालित रूप से उपयोग किया जाएगा:

का उदाहरण लिखने:

Ok(Json.toJson(entities.map(s => Json.toJson(s)))) 

का उदाहरण पढ़ा (मैं शरीर से json पढ़कर एक इकाई बनाने के लिए पोस्ट कर के अपने उदाहरण डाल) कृपया नोटिस addressReads यहाँ

def create = Action(parse.json) { request => 
     request.body.validate(addressReads).map { entity => 
      Addresses.insert(entity) 
      Ok(RestResponses.toJson(RestResponse(OK, "Succesfully created a new entity."))) 
     }.recover { Result => 
      BadRequest(RestResponses.toJson(RestResponse(BAD_REQUEST, "Unable to transform JSON body to entity."))) 
     } 
} 

इस्तेमाल किया अंत में, वे करने की कोशिश की (और succeded) बनाने के लिए जेएसओएन के बारे में चीजें बहुत सरल हैं।

Answer 3

मैं जेसन स्ट्रिंग में ऑब्जेक्ट्स को कन्वर्ट करने के लिए अपने प्रोजेक्ट में जेरिकसन (जो मूल रूप से जैकेटन के लिए रैपर है) का उपयोग कर रहा हूं।

ऐसा करने के लिए सबसे आसान तरीका है:

import com.codehale.jerkson.Json._ 
... 
generate(milo) 
... 

आप ObjectMapper विन्यस्त करने की जरूरत है (उदाहरण के जोड़ने कस्टम serializer/deserializer, को विन्यस्त उत्पादन प्रारूप, आदि), आप ऑब्जेक्ट बनाकर ऐसा कर सकते हैं जो com.codehale.jerkson.Json कक्षा को बढ़ाता है।

package utils 

import org.codehaus.jackson.map._ 
import org.codehaus.jackson.{Version, JsonGenerator, JsonParser} 
import com.codahale.jerkson.Json 
import org.codehaus.jackson.map.module.SimpleModule 
import org.codehaus.jackson.map.annotate.JsonSerialize 

object CustomJson extends Json { 

    val module = new SimpleModule("CustomSerializer", Version.unknownVersion()) 

    // --- (SERIALIZERS) --- 
    // Example: 
    // module.addSerializer(classOf[Enumeration#Value], EnumerationSerializer) 
    // --- (DESERIALIZERS) --- 
    // Example: 
    // module.addDeserializer(classOf[MyEnumType], new EnumerationDeserializer[MyEnumType](MyEnumTypes)) 

    mapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL) 
    mapper.setSerializationConfig(mapper.getSerializationConfig.without(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES)) 
    mapper.registerModule(module) 
} 

अपने कोड में उपयोग करने के लिए:

import utils.CustomJson._ 
... 
generate(milo) 
... 

Answer 4

वास्तव में, यह बहुत सरल है। सबसे पहले आयात:

val milo:User = new User("Millad","Dagdoni",23) 
implicit val userImplicitWrites = Json.writes[User] 
Json.toJson(milo) 

मैं इसे डॉक्स में पाया है:

import play.api.libs.json._ 

तथ्य के लिए धन्यवाद, कि उपयोगकर्ता एक मामले वर्ग आप स्वचालित रूप से Json का उपयोग कर Json.writes [] लिखते हैं बना सकते हैं , लेकिन यहां एपीआई का लिंक है: http://www.playframework.com/documentation/2.2.x/api/scala/index.html#play.api.libs.json.Json $

Answer 5

आपके मामले में, मैं JSON.format मैक्रो का उपयोग करूंगा।

import play.api.libs.json._ 
implicit val userFormat = Json.format[User] 
val milo = new User("Sam", "Fisher", 23) 
val json = Json.toJson(milo)