রেজাল্টসেটকে JSON এ সর্বাধিক দক্ষ রূপান্তর?


109

নিম্নলিখিত কোড একটি পরিবর্তিত ResultSetব্যবহার করে একটি JSON স্ট্রিংকে করতে JSONArrayএবং JSONObject

import org.json.JSONArray;
import org.json.JSONObject;
import org.json.JSONException;

import java.sql.SQLException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

public class ResultSetConverter {
  public static JSONArray convert( ResultSet rs )
    throws SQLException, JSONException
  {
    JSONArray json = new JSONArray();
    ResultSetMetaData rsmd = rs.getMetaData();

    while(rs.next()) {
      int numColumns = rsmd.getColumnCount();
      JSONObject obj = new JSONObject();

      for (int i=1; i<numColumns+1; i++) {
        String column_name = rsmd.getColumnName(i);

        if(rsmd.getColumnType(i)==java.sql.Types.ARRAY){
         obj.put(column_name, rs.getArray(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.BIGINT){
         obj.put(column_name, rs.getInt(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.BOOLEAN){
         obj.put(column_name, rs.getBoolean(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.BLOB){
         obj.put(column_name, rs.getBlob(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.DOUBLE){
         obj.put(column_name, rs.getDouble(column_name)); 
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.FLOAT){
         obj.put(column_name, rs.getFloat(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.INTEGER){
         obj.put(column_name, rs.getInt(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.NVARCHAR){
         obj.put(column_name, rs.getNString(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.VARCHAR){
         obj.put(column_name, rs.getString(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.TINYINT){
         obj.put(column_name, rs.getInt(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.SMALLINT){
         obj.put(column_name, rs.getInt(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.DATE){
         obj.put(column_name, rs.getDate(column_name));
        }
        else if(rsmd.getColumnType(i)==java.sql.Types.TIMESTAMP){
        obj.put(column_name, rs.getTimestamp(column_name));   
        }
        else{
         obj.put(column_name, rs.getObject(column_name));
        }
      }

      json.put(obj);
    }

    return json;
  }
}
  • একটি দ্রুত উপায় আছে কি?
  • এমন কোনও উপায় আছে যা কম স্মৃতি ব্যবহার করে?

1
একটি পৃথক বাস্তবায়ন কোড. google.com/p/bonex-homerunning/source/browse/trunk/…
লাইফ গ্রুইনওল্ড

1
java.sql.Types.ARRAY এর জন্য বাস্তবায়ন আমার জন্য পোস্টগ্র্যাস্কল ব্যবহার করে কাজ করে নি (অ্যারে "{...}" ব্যবহার করে স্ট্রিং হিসাবে লেখা রয়েছে) "অবজেক্ট" লাইন পরিবর্তন করে শেষ হয়েছে "কলাম_নাম, আরএস.জেটআরে (কলাম_নাম)" ); "থেকে" অ্যারে অ্যারে = rs.getArray (কলাম_নাম); যদি (অ্যারে! = নাল) obj.put (কলাম_নাম, নতুন JSONArray (অ্যারে.getArray ())); "
আণবিক

যদি পারফরম্যান্স একটি বড় সমস্যা হয় তবে আপনার এই JSON এপিআই ব্যবহার করা উচিত নয় বরং এমন স্ট্রিমিং লাইব্রেরি ব্যবহার করা উচিত যা কেবলমাত্র JSON লিখে সমস্ত ডেটার মেমরি অবজেক্ট তৈরি করার প্রয়োজন ছাড়াই (যেখানে আপনি গাছটির পিছনে ফিরে দেখতে পারেন / জিনিসগুলি দেখতে পারেন)। এটি বলেছিল, আমি নিশ্চিত করব যে এটি করার আগে আপনার কাছে কার্যত কোনও সমস্যা আছে।
সেবাস্তিয়ান ভ্যান ডেন ব্রুক

3
আপনার স্নিপেটে একটি ত্রুটি আছে। java.sql.Types.BIGINT8, আকার বাইট তাই এটি সঙ্গে পড়া করা আবশ্যক rs.getLong()নাrs.getInt()
polarfish

3
এটি লোড করার জন্য ধন্যবাদ। আপনি সবেমাত্র আমাকে ঘন্টা ধরে কাজের মূল্য বাঁচিয়েছেন।
ড্রিচ

উত্তর:


23

এটি কেবল শাখা এবং বেসিক পরীক্ষাগুলি থেকে জেআইটি সংকলক সম্ভবত এটি বেশ দ্রুত তৈরি করতে চলেছে। আপনি সম্ভবত একটি কলব্যাকের জন্য হ্যাশম্যাপ লুপের সাহায্যে এটি আরও মার্জিত করে তুলতে পারেন তবে আমি সন্দেহ করি এটি আরও দ্রুততর হবে। মেমরি হিসাবে, এটি হিসাবে বেশ পাতলা।

কোনওভাবেই আমি সন্দেহ করি যে এই কোডটি আসলে মেমরি বা পারফরম্যান্সের জন্য একটি গুরুত্বপূর্ণ বোতল ঘাড় neck এটিকে অপ্টিমাইজ করার চেষ্টা করার কোনও সত্যিকারের যুক্তি আছে কি?


আমি উত্স কোডটি একটি ওপেন-সোর্স কাঠামোর মধ্যে রাখছি, সুতরাং এটি কী জন্য ব্যবহৃত হবে তা আমি জানি না। তাই আমি এটি যথাসম্ভব দক্ষ করার চেষ্টা করছি।
ডেভিন ডিকসন

1
@ ডেভিনিডিক্সন: কাঠামোটি কি পাওয়া যায়? আপনার প্রশ্নের কোডের মতো কিছু কি আগেই কোথাও একটি মুক্ত উত্স রেপোতে পাওয়া যায়?

34

আমি মনে করি কম মেমোরি ব্যবহার করার একটি উপায় আছে (ডেটা কার্ডিনালিটির উপর নির্ভর করে একটি স্থির এবং লিনিয়ার পরিমাণ) তবে এটি পদ্ধতির স্বাক্ষরকে পরিবর্তিত করার জন্য বোঝায়। বাস্তবে আমরা ফলাফলটিসেট থেকে আনার সাথে সাথে আমরা জসন ডেটা সরাসরি আউটপুট স্ট্রিমে মুদ্রণ করতে পারি: ইতিমধ্যে লিখিত তথ্য আবর্জনা সংগ্রহ করা হবে কারণ আমাদের স্মৃতিতে রাখে এমন কোনও অ্যারের প্রয়োজন নেই।

আমি জিএসএন ব্যবহার করি যা টাইপ অ্যাডাপ্টার গ্রহণ করে। রেজাল্টসেটকে জসনআররে রূপান্তর করতে আমি একটি টাইপ অ্যাডাপ্টার লিখেছিলাম এবং এটি আপনার কোডের মতো দেখতে খুব ভাল লাগে। আমি "গসন ২.১: টার্গেটেড ডিসেম্বর ৩১, ২০১১" প্রকাশের অপেক্ষায় রয়েছি যার "ব্যবহারকারীর সংজ্ঞায়িত স্ট্রিমিং টাইপ অ্যাডাপ্টারের জন্য সমর্থন" থাকবে। তারপরে আমি আমার অ্যাডাপ্টারকে স্ট্রিমিং অ্যাডাপ্টার হিসাবে পরিবর্তন করব।


হালনাগাদ

প্রতিশ্রুত হিসাবে আমি ফিরে এসেছি তবে জ্যাকসনের সাথে নয়, বরং জ্যাকসন ২ এর সাথে এসেছি।

উপস্থাপনা: ফলাফলের কম স্মৃতি ব্যবহার করার কী এটি "সার্ভার সাইড" কার্সারে রয়েছে। এই ধরণের কার্সারের সাথে (জাভা ডেভুসে ওরফে রেজাল্ট) ডিবিএমএস ক্লায়েন্টটি পড়ার সাথে সাথে এগিয়ে যাওয়ার সাথে সাথে ক্লায়েন্টকে (ওরফে ড্রাইভার) বর্ধিত তথ্য প্রেরণ করে। আমি মনে করি ওরাকল কার্সারটি ডিফল্টরূপে সার্ভার পাশাপাশি রয়েছে। মাইএসকিউএল> 5.0.2 এর জন্য সংযোগ ইউআরএল প্যারামেন্টারে ব্যবহারকার্সারফ্যাচটি দেখুন । আপনার প্রিয় ডিবিএমএস সম্পর্কে পরীক্ষা করুন।

1: সুতরাং কম স্মৃতি ব্যবহার করার জন্য আমাদের অবশ্যই:

  • দৃশ্যের পিছনে সার্ভার সাইড কার্সার ব্যবহার করুন
  • ব্যবহারের খোলা resultset যেমন শুধুমাত্র পাঠযোগ্য এবং, অবশ্যই, এগিয়ে শুধুমাত্র ;
  • একটি তালিকাতে সমস্ত কার্সার লোড করা এড়াতে (বা ক JSONArray) তবে প্রতিটি সারি সরাসরি আউটপুট লাইনে লিখুন , যেখানে আউটপুট লাইনের অর্থ আমি একটি আউটপুট স্ট্রিম বা লেখক বা একটি জেসন জেনারেটর যা আউটপুট স্ট্রিম বা লেখককে আবৃত করে।

2: জ্যাকসন ডকুমেন্টেশন যেমন বলে:

স্ট্রিমিং এপিআই সেরা পারফর্ম করছে (সর্বনিম্ন ওভারহেড, দ্রুত পড়ুন / লিখুন; অন্যান্য 2 পদ্ধতি এতে তৈরি করে)

3: আমি আপনাকে দেখছি আপনার কোডটি getInt, getBoolean ব্যবহার করে। getFloat ... রেজাল্টসেটের নিছক ছিল না । আমি আশা করি এটির ফলে সমস্যা হতে পারে।

4: আমি ক্যাশে চিন্তা করতে এবং প্রতিটি পুনরাবৃত্তিকে কলকারীদের কল এড়াতে অ্যারে ব্যবহার করেছি। যদিও স্যুইচ / কেস কনস্ট্রাক্টের কোনও অনুরাগী না হলেও আমি এটি intএসকিউএল এর জন্য ব্যবহার করেছি Types

উত্তর: এখনও পুরোপুরি পরীক্ষা করা হয়নি, এটি জ্যাকসন ২.২ এর উপর ভিত্তি করে :

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.2.2</version>
</dependency>

ResultSetSerializerবস্তু কিভাবে ধারাবাহিকভাবে করার জন্য একটি ResultSet (তাদেরকে JSON বস্তুর tranform) এ জ্যাকসন নির্দেশ দেয়। এটি ভিতরে জ্যাকসন স্ট্রিমিং এপিআই ব্যবহার করে। এখানে একটি পরীক্ষার কোড:

SimpleModule module = new SimpleModule();
module.addSerializer(new ResultSetSerializer());

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(module);

[ . . . do the query . . . ]
ResultSet resultset = statement.executeQuery(query);

// Use the DataBind Api here
ObjectNode objectNode = objectMapper.createObjectNode();

// put the resultset in a containing structure
objectNode.putPOJO("results", resultset);

// generate all
objectMapper.writeValue(stringWriter, objectNode);

এবং, অবশ্যই, রেজাল্টসেটরিশিয়াল শ্রেণীর কোড:

public class ResultSetSerializer extends JsonSerializer<ResultSet> {

    public static class ResultSetSerializerException extends JsonProcessingException{
        private static final long serialVersionUID = -914957626413580734L;

        public ResultSetSerializerException(Throwable cause){
            super(cause);
        }
    }

    @Override
    public Class<ResultSet> handledType() {
        return ResultSet.class;
    }

    @Override
    public void serialize(ResultSet rs, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {

        try {
            ResultSetMetaData rsmd = rs.getMetaData();
            int numColumns = rsmd.getColumnCount();
            String[] columnNames = new String[numColumns];
            int[] columnTypes = new int[numColumns];

            for (int i = 0; i < columnNames.length; i++) {
                columnNames[i] = rsmd.getColumnLabel(i + 1);
                columnTypes[i] = rsmd.getColumnType(i + 1);
            }

            jgen.writeStartArray();

            while (rs.next()) {

                boolean b;
                long l;
                double d;

                jgen.writeStartObject();

                for (int i = 0; i < columnNames.length; i++) {

                    jgen.writeFieldName(columnNames[i]);
                    switch (columnTypes[i]) {

                    case Types.INTEGER:
                        l = rs.getInt(i + 1);
                        if (rs.wasNull()) {
                            jgen.writeNull();
                        } else {
                            jgen.writeNumber(l);
                        }
                        break;

                    case Types.BIGINT:
                        l = rs.getLong(i + 1);
                        if (rs.wasNull()) {
                            jgen.writeNull();
                        } else {
                            jgen.writeNumber(l);
                        }
                        break;

                    case Types.DECIMAL:
                    case Types.NUMERIC:
                        jgen.writeNumber(rs.getBigDecimal(i + 1));
                        break;

                    case Types.FLOAT:
                    case Types.REAL:
                    case Types.DOUBLE:
                        d = rs.getDouble(i + 1);
                        if (rs.wasNull()) {
                            jgen.writeNull();
                        } else {
                            jgen.writeNumber(d);
                        }
                        break;

                    case Types.NVARCHAR:
                    case Types.VARCHAR:
                    case Types.LONGNVARCHAR:
                    case Types.LONGVARCHAR:
                        jgen.writeString(rs.getString(i + 1));
                        break;

                    case Types.BOOLEAN:
                    case Types.BIT:
                        b = rs.getBoolean(i + 1);
                        if (rs.wasNull()) {
                            jgen.writeNull();
                        } else {
                            jgen.writeBoolean(b);
                        }
                        break;

                    case Types.BINARY:
                    case Types.VARBINARY:
                    case Types.LONGVARBINARY:
                        jgen.writeBinary(rs.getBytes(i + 1));
                        break;

                    case Types.TINYINT:
                    case Types.SMALLINT:
                        l = rs.getShort(i + 1);
                        if (rs.wasNull()) {
                            jgen.writeNull();
                        } else {
                            jgen.writeNumber(l);
                        }
                        break;

                    case Types.DATE:
                        provider.defaultSerializeDateValue(rs.getDate(i + 1), jgen);
                        break;

                    case Types.TIMESTAMP:
                        provider.defaultSerializeDateValue(rs.getTime(i + 1), jgen);
                        break;

                    case Types.BLOB:
                        Blob blob = rs.getBlob(i);
                        provider.defaultSerializeValue(blob.getBinaryStream(), jgen);
                        blob.free();
                        break;

                    case Types.CLOB:
                        Clob clob = rs.getClob(i);
                        provider.defaultSerializeValue(clob.getCharacterStream(), jgen);
                        clob.free();
                        break;

                    case Types.ARRAY:
                        throw new RuntimeException("ResultSetSerializer not yet implemented for SQL type ARRAY");

                    case Types.STRUCT:
                        throw new RuntimeException("ResultSetSerializer not yet implemented for SQL type STRUCT");

                    case Types.DISTINCT:
                        throw new RuntimeException("ResultSetSerializer not yet implemented for SQL type DISTINCT");

                    case Types.REF:
                        throw new RuntimeException("ResultSetSerializer not yet implemented for SQL type REF");

                    case Types.JAVA_OBJECT:
                    default:
                        provider.defaultSerializeValue(rs.getObject(i + 1), jgen);
                        break;
                    }
                }

                jgen.writeEndObject();
            }

            jgen.writeEndArray();

        } catch (SQLException e) {
            throw new ResultSetSerializerException(e);
        }
    }
}

27

দুটি জিনিস যা এটি দ্রুত তৈরি করবে:

আপনার কলটি rsmd.getColumnCount()কিছুক্ষণের বাইরে চলে যান । কলামের গণনা সারিগুলিতে পৃথক হওয়া উচিত নয়।

প্রতিটি কলামের ধরণের জন্য, আপনি এই জাতীয় কিছু কল করে শেষ করবেন:

obj.put(column_name, rs.getInt(column_name));

কলাম মানটি পুনরুদ্ধার করতে কলাম সূচকটি ব্যবহার করা কিছুটা দ্রুত হবে:

obj.put(column_name, rs.getInt(i));

String column_name;লুপের বাইরেও সংজ্ঞা দিন ।
চার্নি কায়ে

22

একটি সহজ সমাধান (প্রশ্নের কোডের ভিত্তিতে):

JSONArray json = new JSONArray();
ResultSetMetaData rsmd = rs.getMetaData();
while(rs.next()) {
  int numColumns = rsmd.getColumnCount();
  JSONObject obj = new JSONObject();
  for (int i=1; i<=numColumns; i++) {
    String column_name = rsmd.getColumnName(i);
    obj.put(column_name, rs.getObject(column_name));
  }
  json.put(obj);
}
return json;

3
দুর্দান্ত, তবে DATETIME এবং TIMESTAMP এর সাথে একটি বাগ রয়েছে (এতে
অ্যাপোসট্রোফ

সুন্দর এবং সহজ
অনুপ এলএল

10

আপনি কাজের জন্য jOOQ ব্যবহার করতে পারেন । কিছু দরকারী জেডিবিসি এক্সটেনশনের সুবিধা নিতে আপনাকে জওউকিউ এর সমস্ত বৈশিষ্ট্য ব্যবহার করতে হবে না। এক্ষেত্রে সহজভাবে লিখুন:

String json = DSL.using(connection).fetch(resultSet).formatJSON();

প্রাসঙ্গিক এপিআই পদ্ধতিগুলি হ'ল:

  • DSLContext.fetch(ResultSet) একটি জেডিবিসি রেজাল্টসেটকে একটি জোকিউ ফলাফলে রূপান্তর করতে।
  • Result.formatJSON() JOOQ ফলাফলকে JSON স্ট্রিংয়ে ফর্ম্যাট করতে।

ফলাফলের ফর্ম্যাটিং এর মতো দেখাবে:

{"fields":[{"name":"field-1","type":"type-1"},
           {"name":"field-2","type":"type-2"},
           ...,
           {"name":"field-n","type":"type-n"}],
 "records":[[value-1-1,value-1-2,...,value-1-n],
            [value-2-1,value-2-2,...,value-2-n]]}

আপনি নিজের ফর্ম্যাটিংটি বরং সহজেই তৈরি করতে পারেন Result.map(RecordMapper)

এটি মূলত আপনার কোডের মতোই কাজ করে, জেএসওএন অবজেক্টগুলির প্রজন্মকে বিপদে ফেলে সরাসরি "এ" স্ট্রিমিং করে StringBuilder। আমি বলব যে পারফরম্যান্সের ওভারহেড উভয় ক্ষেত্রেই নগণ্য হওয়া উচিত।

(অস্বীকৃতি: আমি JOOQ এর পিছনে সংস্থার পক্ষে কাজ করি)


এটি দুর্দান্ত but তবে ফলাফলের স্ট্রিংটি বিশ্লেষণ করতে আমার সমস্যা হচ্ছে কিছু মান যখন একটি উদ্ধৃতি চিহ্ন ধারণ করে তখন পার্সার সঠিকভাবে কাজ করতে পারে না: আমি মনে করি যে একটি কার্যকর JSON স্ট্রিং তৈরি "করতে মানগুলির অভ্যন্তরের উদ্ধৃতি চিহ্নগুলি ( থেকে \") এড়ানো উচিত । এটি কি formatJSON()ফাংশনটির একটি বাগ ? নাকি আমি কিছু মিস করছি?
ওয়ানিরস

@ অ্যানিরোস: জুইউকিউকে সেই উদ্ধৃতি চিহ্নগুলি সঠিকভাবে পালানো উচিত ... সেরা একটি নতুন প্রশ্ন জিজ্ঞাসা করুন (বিশদ সহ) বা বাগ রিপোর্ট করুন: github.com/jOOQ/jOOQ/issues/new
লুকাশ

আপনার উদাহরণে, ফলাফলসেটটি কী ব্যবহৃত হয় fetch(resultSet)? এটি কোথাও সংজ্ঞায়িত করা হয়নি। এবং জেডিবিসি ResultSetআনার আগে যদি আমি পাই তবে এর উদ্দেশ্য কী DSL.using(connection)? কেন এটি সংযোগ প্রয়োজন? :)
নিকোলা লোইজি

1
@ নিকোলাওজিš: ঠিক আছে, প্রশ্নটি জেডিবিসি ব্যবহারের বিষয়ে জিজ্ঞাসা করে ResultSet, তাই আমার মনে হয় এ নিয়ে কোনও সন্দেহ নেই ResultSet। প্রকৃতপক্ষে, কেন এটি connectionএখানে প্রয়োজন তা সুস্পষ্ট বলে মনে হচ্ছে না । আপনি যদি জওকিউ ব্যবহার করছেন তবে আপনার কাছে DSLContext(তবে এর ফলাফল DSL.using(connection)বা এর সমান) যে কোনও উপায়ে আপনার কাছে উপলভ্য থাকবে।
লুকাস এদার

অন্তর্ভুক্ত করার জন্য সঠিক JOOQ গ্রন্থাগারটি কী? আমি অনেক চেষ্টা করছি কিন্তু প্রত্যেকে আমাকে ডিএসএল রেফারেন্সের সাথে ক্লাসের ত্রুটি খুঁজে পায়নি। ধন্যবাদ
লরেঞ্জো

7

@ জিম কুকের দেওয়া পরামর্শ ছাড়াও। অন্য একটি চিন্তাভাবনা হল if-elses এর পরিবর্তে একটি স্যুইচ ব্যবহার করা:

while(rs.next()) {
  int numColumns = rsmd.getColumnCount();
  JSONObject obj = new JSONObject();

  for( int i=1; i<numColumns+1; i++) {
    String column_name = rsmd.getColumnName(i);

    switch( rsmd.getColumnType( i ) ) {
      case java.sql.Types.ARRAY:
        obj.put(column_name, rs.getArray(column_name));     break;
      case java.sql.Types.BIGINT:
        obj.put(column_name, rs.getInt(column_name));       break;
      case java.sql.Types.BOOLEAN:
        obj.put(column_name, rs.getBoolean(column_name));   break;
      case java.sql.Types.BLOB:
        obj.put(column_name, rs.getBlob(column_name));      break;
      case java.sql.Types.DOUBLE:
        obj.put(column_name, rs.getDouble(column_name));    break;
      case java.sql.Types.FLOAT:
        obj.put(column_name, rs.getFloat(column_name));     break;
      case java.sql.Types.INTEGER:
        obj.put(column_name, rs.getInt(column_name));       break;
      case java.sql.Types.NVARCHAR:
        obj.put(column_name, rs.getNString(column_name));   break;
      case java.sql.Types.VARCHAR:
        obj.put(column_name, rs.getString(column_name));    break;
      case java.sql.Types.TINYINT:
        obj.put(column_name, rs.getInt(column_name));       break;
      case java.sql.Types.SMALLINT:
        obj.put(column_name, rs.getInt(column_name));       break;
      case java.sql.Types.DATE:
        obj.put(column_name, rs.getDate(column_name));      break;
      case java.sql.Types.TIMESTAMP:
        obj.put(column_name, rs.getTimestamp(column_name)); break;
      default:
        obj.put(column_name, rs.getObject(column_name));    break;
    }
  }

  json.put(obj);
}

4
পিছনের দিকে লুপিং (সূচকের শূন্যের তুলনা করা) আরও দ্রুত (সূচককে একটি অভিব্যক্তির সাথে তুলনা করার চেয়ে) দ্রুত।
ডেভ জার্ভিস

4

এই উত্তরটি সবচেয়ে দক্ষ নাও হতে পারে তবে এটি অবশ্যই গতিশীল। গুগলের জিসন লাইব্রেরির সাথে নেটিভ জেডিবিসি যুক্ত করে, আমি সহজেই এসকিউএল ফলাফল থেকে জেএসএন স্ট্রিমে রূপান্তর করতে পারি।

আমি রূপান্তরকারী, উদাহরণস্বরূপ ডিবি বৈশিষ্ট্য ফাইল, এসকিউএল টেবিল জেনারেশন এবং একটি গ্রেডল বিল্ড ফাইল (ব্যবহৃত নির্ভরতা সহ) অন্তর্ভুক্ত করেছি।

QueryApp.java

import java.io.PrintWriter;

import com.oracle.jdbc.ResultSetConverter;

public class QueryApp {
    public static void main(String[] args) {
        PrintWriter writer = new PrintWriter(System.out);
        String dbProps = "/database.properties";
        String indent = "    ";

        writer.println("Basic SELECT:");
        ResultSetConverter.queryToJson(writer, dbProps, "SELECT * FROM Beatles", indent, false);

        writer.println("\n\nIntermediate SELECT:");
        ResultSetConverter.queryToJson(writer, dbProps, "SELECT first_name, last_name, getAge(date_of_birth) as age FROM Beatles", indent, true);
    }
}

ResultSetConverter.java

package com.oracle.jdbc;

import java.io.*;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.*;

import com.google.common.reflect.TypeToken;
import com.google.gson.GsonBuilder;
import com.google.gson.stream.JsonWriter;

public class ResultSetConverter {
    public static final Type RESULT_TYPE = new TypeToken<List<Map<String, Object>>>() {
        private static final long serialVersionUID = -3467016635635320150L;
    }.getType();

    public static void queryToJson(Writer writer, String connectionProperties, String query, String indent, boolean closeWriter) {
        Connection conn = null;
        Statement stmt = null;
        GsonBuilder gson = new GsonBuilder();
        JsonWriter jsonWriter = new JsonWriter(writer);

        if (indent != null) jsonWriter.setIndent(indent);

        try {
            Properties props = readConnectionInfo(connectionProperties);
            Class.forName(props.getProperty("driver"));

            conn = openConnection(props);
            stmt = conn.createStatement();

            gson.create().toJson(QueryHelper.select(stmt, query), RESULT_TYPE, jsonWriter);

            if (closeWriter) jsonWriter.close();

            stmt.close();
            conn.close();
        } catch (SQLException se) {
            se.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                if (stmt != null) stmt.close();
            } catch (SQLException se2) {
            }
            try {
                if (conn != null) conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
            try {
                if (closeWriter && jsonWriter != null) jsonWriter.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }

    private static Properties readConnectionInfo(String resource) throws IOException {
        Properties properties = new Properties();
        InputStream in = ResultSetConverter.class.getResourceAsStream(resource);
        properties.load(in);
        in.close();

        return properties;
    }

    private static Connection openConnection(Properties connectionProperties) throws IOException, SQLException {
        String database = connectionProperties.getProperty("database");
        String username = connectionProperties.getProperty("username");
        String password = connectionProperties.getProperty("password");

        return DriverManager.getConnection(database, username, password);
    }
}

QueryHelper.java

package com.oracle.jdbc;

import java.sql.*;
import java.text.*;
import java.util.*;

import com.google.common.base.CaseFormat;

public class QueryHelper {
    static DateFormat DATE_FORMAT = new SimpleDateFormat("YYYY-MM-dd");

    public static List<Map<String, Object>> select(Statement stmt, String query) throws SQLException {
        ResultSet resultSet = stmt.executeQuery(query);
        List<Map<String, Object>> records = mapRecords(resultSet);

        resultSet.close();

        return records;
    }

    public static List<Map<String, Object>> mapRecords(ResultSet resultSet) throws SQLException {
        List<Map<String, Object>> records = new ArrayList<Map<String, Object>>();
        ResultSetMetaData metaData = resultSet.getMetaData();

        while (resultSet.next()) {
            records.add(mapRecord(resultSet, metaData));
        }

        return records;
    }

    public static Map<String, Object> mapRecord(ResultSet resultSet, ResultSetMetaData metaData) throws SQLException {
        Map<String, Object> record = new HashMap<String, Object>();

        for (int c = 1; c <= metaData.getColumnCount(); c++) {
            String columnType = metaData.getColumnTypeName(c);
            String columnName = formatPropertyName(metaData.getColumnName(c));
            Object value = resultSet.getObject(c);

            if (columnType.equals("DATE")) {
                value = DATE_FORMAT.format(value);
            }

            record.put(columnName, value);
        }

        return record;
    }

    private static String formatPropertyName(String property) {
        return CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, property);
    }
}

database.properties

driver=com.mysql.jdbc.Driver
database=jdbc:mysql://localhost/JDBC_Tutorial
username=root
password=

JDBC_Tutorial.sql

-- phpMyAdmin SQL Dump
-- version 4.5.1
-- http://www.phpmyadmin.net
--
-- Host: 127.0.0.1
-- Generation Time: Jan 12, 2016 at 07:40 PM
-- Server version: 10.1.8-MariaDB
-- PHP Version: 5.6.14

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET time_zone = "+00:00";


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- Database: `jdbc_tutorial`
--
CREATE DATABASE IF NOT EXISTS `jdbc_tutorial` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
USE `jdbc_tutorial`;

DELIMITER $$
--
-- Functions
--
DROP FUNCTION IF EXISTS `getAge`$$
CREATE DEFINER=`root`@`localhost` FUNCTION `getAge` (`in_dob` DATE) RETURNS INT(11) NO SQL
BEGIN
DECLARE l_age INT;
   IF DATE_FORMAT(NOW(),'00-%m-%d') >= DATE_FORMAT(in_dob,'00-%m-%d') THEN
      -- This person has had a birthday this year
      SET l_age=DATE_FORMAT(NOW(),'%Y')-DATE_FORMAT(in_dob,'%Y');
   ELSE
      -- Yet to have a birthday this year
      SET l_age=DATE_FORMAT(NOW(),'%Y')-DATE_FORMAT(in_dob,'%Y')-1;
   END IF;
      RETURN(l_age);
END$$

DELIMITER ;

-- --------------------------------------------------------

--
-- Table structure for table `beatles`
--

DROP TABLE IF EXISTS `beatles`;
CREATE TABLE IF NOT EXISTS `beatles` (
  `id` int(11) NOT NULL,
  `first_name` varchar(255) DEFAULT NULL,
  `last_name` varchar(255) DEFAULT NULL,
  `date_of_birth` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

--
-- Truncate table before insert `beatles`
--

TRUNCATE TABLE `beatles`;
--
-- Dumping data for table `beatles`
--

INSERT INTO `beatles` (`id`, `first_name`, `last_name`, `date_of_birth`) VALUES(100, 'John', 'Lennon', '1940-10-09');
INSERT INTO `beatles` (`id`, `first_name`, `last_name`, `date_of_birth`) VALUES(101, 'Paul', 'McCartney', '1942-06-18');
INSERT INTO `beatles` (`id`, `first_name`, `last_name`, `date_of_birth`) VALUES(102, 'George', 'Harrison', '1943-02-25');
INSERT INTO `beatles` (`id`, `first_name`, `last_name`, `date_of_birth`) VALUES(103, 'Ringo', 'Starr', '1940-07-07');

/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;

build.gradle

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application'

mainClassName = 'com.oracle.jdbc.QueryApp'

repositories {
    maven  {
        url "http://repo1.maven.org/maven2"
    }
}

jar {
    baseName = 'jdbc-tutorial'
    version =  '1.0.0'
}

sourceCompatibility = 1.7
targetCompatibility = 1.7

dependencies {
    compile 'mysql:mysql-connector-java:5.1.16'
    compile 'com.google.guava:guava:18.0'
    compile 'com.google.code.gson:gson:1.7.2'
}

task wrapper(type: Wrapper) {
    gradleVersion = '2.9'
}

ফলাফল

বেসিক নির্বাচন

[
    {
        "firstName": "John",
        "lastName": "Lennon",
        "dateOfBirth": "1940-10-09",
        "id": 100
    },
    {
        "firstName": "Paul",
        "lastName": "McCartney",
        "dateOfBirth": "1942-06-18",
        "id": 101
    },
    {
        "firstName": "George",
        "lastName": "Harrison",
        "dateOfBirth": "1943-02-25",
        "id": 102
    },
    {
        "firstName": "Ringo",
        "lastName": "Starr",
        "dateOfBirth": "1940-07-07",
        "id": 103
    }
]

অন্তর্বর্তী নির্বাচন

[
    {
        "firstName": "John",
        "lastName": "Lennon",
        "age": 75
    },
    {
        "firstName": "Paul",
        "lastName": "McCartney",
        "age": 73
    },
    {
        "firstName": "George",
        "lastName": "Harrison",
        "age": 72
    },
    {
        "firstName": "Ringo",
        "lastName": "Starr",
        "age": 75
    }
]

3

প্রথম কলামের নাম প্রাক-উত্পন্ন, rs.getString(i)পরিবর্তে দ্বিতীয় ব্যবহার rs.getString(column_name)

নিম্নলিখিত এটির একটি বাস্তবায়ন:

    /*
     * Convert ResultSet to a common JSON Object array
     * Result is like: [{"ID":"1","NAME":"Tom","AGE":"24"}, {"ID":"2","NAME":"Bob","AGE":"26"}, ...]
     */
    public static List<JSONObject> getFormattedResult(ResultSet rs) {
        List<JSONObject> resList = new ArrayList<JSONObject>();
        try {
            // get column names
            ResultSetMetaData rsMeta = rs.getMetaData();
            int columnCnt = rsMeta.getColumnCount();
            List<String> columnNames = new ArrayList<String>();
            for(int i=1;i<=columnCnt;i++) {
                columnNames.add(rsMeta.getColumnName(i).toUpperCase());
            }

            while(rs.next()) { // convert each object to an human readable JSON object
                JSONObject obj = new JSONObject();
                for(int i=1;i<=columnCnt;i++) {
                    String key = columnNames.get(i - 1);
                    String value = rs.getString(i);
                    obj.put(key, value);
                }
                resList.add(obj);
            }
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return resList;
    }

আমি কীভাবে এই অ্যাক্সেসটি ব্যবহার করব এবং কীভাবে ব্যবহার করব .... বলুন আমি পুরো নাম কলামটি মুদ্রণ করতে চাই..আর সিআরইউডি ক্রিয়াকলাপের জন্য সহজেই কী অবজেক্টটি পাওয়া যায় ??
প্রথমেশ ধনবাদে

@ প্রথমেশ্বাদনওয়াদে এই পদ্ধতিটি জেডিবিসি রেজাল্টসেটকে একটি জেএসওন অ্যারেতে গোপন করা। বিকাশকারীরা সাধারণত কাঁচা জেডিবিসি রেজাল্টসেট ব্যবহার করেন না, তারা সাধারণত এটিকে জাভা অবজেক্টের তালিকায় অর্থাৎ জেএসওএন অবজেক্টে রূপান্তর করেন। আপনি দেখেন যে রিটার্ন মানটি JSON অবজেক্টের একটি অ্যারে। আপনি সহজেই একটি অবজেক্টের মাধ্যমে অ্যাক্সেস করতে পারবেন JSONObject json = resList.get(i);তারপরে আপনি JSON অবজেক্টটি পরিচালনা করতে মুক্ত json
কোডার্জ

একটি গ্রাফিকাল ভিউ প্রস্তুত করার জন্য আসলে আমার প্রয়োজন হবে। সুতরাং আমি শুধু কৌতূহলী আমি অবজেক্টটি চালিত করতে পারি। Thnx।
প্রথমেশ ধনবাদে

আপনি দয়া করে "গ্রাফিকাল ভিউ" বর্ণনা করতে পারেন? নাকি একটি উদাহরণ দেওয়া হয়েছে?
কোডার্জ

আমি কলামের মানটি এ হিসাবে প্রদর্শন করার চেষ্টা করছি: JSONObject obj = jsonList.get (1); System.out.println (obj.getString ( "নাম") + + "\ টন," + obj.getString ( "কোম্পানী")); তবে "org.json.JSONException: JSONObject [" নাম "] হিসাবে ত্রুটি পাওয়া যায় নি।"
প্রথমেশ ধনবাদে

2

যদি কেউ এই বাস্তবায়নটি ব্যবহার করার পরিকল্পনা করে তবে আপনি এটি এবং এটি পরীক্ষা করে দেখতে চান

এটি সেই রূপান্তর কোডটির আমার সংস্করণ:

public class ResultSetConverter {
public static JSONArray convert(ResultSet rs) throws SQLException,
        JSONException {
    JSONArray json = new JSONArray();
    ResultSetMetaData rsmd = rs.getMetaData();
    int numColumns = rsmd.getColumnCount();
    while (rs.next()) {

        JSONObject obj = new JSONObject();

        for (int i = 1; i < numColumns + 1; i++) {
            String column_name = rsmd.getColumnName(i);

            if (rsmd.getColumnType(i) == java.sql.Types.ARRAY) {
                obj.put(column_name, rs.getArray(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.BIGINT) {
                obj.put(column_name, rs.getLong(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.REAL) {
                obj.put(column_name, rs.getFloat(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.BOOLEAN) {
                obj.put(column_name, rs.getBoolean(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.BLOB) {
                obj.put(column_name, rs.getBlob(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.DOUBLE) {
                obj.put(column_name, rs.getDouble(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.FLOAT) {
                obj.put(column_name, rs.getDouble(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.INTEGER) {
                obj.put(column_name, rs.getInt(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.NVARCHAR) {
                obj.put(column_name, rs.getNString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.VARCHAR) {
                obj.put(column_name, rs.getString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.CHAR) {
                obj.put(column_name, rs.getString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.NCHAR) {
                obj.put(column_name, rs.getNString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.LONGNVARCHAR) {
                obj.put(column_name, rs.getNString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.LONGVARCHAR) {
                obj.put(column_name, rs.getString(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.TINYINT) {
                obj.put(column_name, rs.getByte(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.SMALLINT) {
                obj.put(column_name, rs.getShort(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.DATE) {
                obj.put(column_name, rs.getDate(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.TIME) {
                obj.put(column_name, rs.getTime(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.TIMESTAMP) {
                obj.put(column_name, rs.getTimestamp(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.BINARY) {
                obj.put(column_name, rs.getBytes(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.VARBINARY) {
                obj.put(column_name, rs.getBytes(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.LONGVARBINARY) {
                obj.put(column_name, rs.getBinaryStream(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.BIT) {
                obj.put(column_name, rs.getBoolean(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.CLOB) {
                obj.put(column_name, rs.getClob(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.NUMERIC) {
                obj.put(column_name, rs.getBigDecimal(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.DECIMAL) {
                obj.put(column_name, rs.getBigDecimal(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.DATALINK) {
                obj.put(column_name, rs.getURL(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.REF) {
                obj.put(column_name, rs.getRef(column_name));
            } else if (rsmd.getColumnType(i) == java.sql.Types.STRUCT) {
                obj.put(column_name, rs.getObject(column_name)); // must be a custom mapping consists of a class that implements the interface SQLData and an entry in a java.util.Map object.
            } else if (rsmd.getColumnType(i) == java.sql.Types.DISTINCT) {
                obj.put(column_name, rs.getObject(column_name)); // must be a custom mapping consists of a class that implements the interface SQLData and an entry in a java.util.Map object.
            } else if (rsmd.getColumnType(i) == java.sql.Types.JAVA_OBJECT) {
                obj.put(column_name, rs.getObject(column_name));
            } else {
                obj.put(column_name, rs.getString(i));
            }
        }

        json.put(obj);
    }

    return json;
}
}

2

ঠিক যেমন শীর্ষস্থানীয় হয়, if / then লুপটি এনামগুলিতে স্যুইচ করার চেয়ে আরও দক্ষ। আপনার যদি কাঁচা এনাম পূর্ণসংখ্যার বিপরীতে স্যুইচ থাকে তবে এটি আরও কার্যকর তবে চলকের বিরুদ্ধে, যদি / তারপরে আরও দক্ষ হয় তবে কমপক্ষে জাভা 5, 6 এবং 7 এর জন্য।

অর্থাত্ কোনও কারণে (কিছু পারফরম্যান্স পরীক্ষার পরে)

if (ordinalValue == 1) {
   ...
} else (ordinalValue == 2 {
   ... 
}

তুলনায় দ্রুত

switch( myEnum.ordinal() ) {
    case 1:
       ...
       break;
    case 2:
       ...
       break;
}

আমি দেখতে পাচ্ছি যে কয়েক জন আমাকে সন্দেহ করছে, সুতরাং আমি এখানে কোড পোস্ট করব যাতে আপনি জাভা from থেকে প্রাপ্ত আউটপুট সহ পার্থক্যটি দেখতে নিজেকে চালাতে পারেন। নিম্নলিখিত 10 টি এনাম মান সহ নিম্নলিখিত কোডের ফলাফল নীচে রয়েছে। এখানে এনফলের অর্ডিনাল ধ্রুবকগুলির সাথে তুলনা করে একটি পূর্ণসংখ্যার মানটি ব্যবহার করা হয় তবে বনাম, প্রতিটি এনাম নামের বিপরীতে এনামের সাথে একটি স্যুইচ, বনাম। যদি / তারপরে একটি পূর্ণসংখ্যার মানটি অন্য দুটি সুইচকে পরাজিত করে, যদিও শেষ স্যুইচটি প্রথম সুইচের চেয়ে কিছুটা দ্রুত ছিল তবে এটি / অন্যটির চেয়ে দ্রুত ছিল না।

/ অন্যথায় 23 এমএস
নিলে 45 টি এমএস
স্যুইচ নিয়েছে 30 এমএস স্যুইচ 2 30 এমএস নিয়েছে
মোট ম্যাচ: 3000000

package testing;

import java.util.Random;

enum TestEnum {
    FIRST,
    SECOND,
    THIRD,
    FOURTH,
    FIFTH,
    SIXTH,
    SEVENTH,
    EIGHTH,
    NINTH,
    TENTH
}

public class SwitchTest {
    private static int LOOP = 1000000;
    private static Random r = new Random();
    private static int SIZE = TestEnum.values().length;

    public static void main(String[] args) {
        long time = System.currentTimeMillis();
        int matches = 0;
        for (int i = 0; i < LOOP; i++) {
            int j = r.nextInt(SIZE);
            if (j == TestEnum.FIRST.ordinal()) {
                matches++;
            } else if (j == TestEnum.SECOND.ordinal()) {
                matches++;
            } else if (j == TestEnum.THIRD.ordinal()) {
                matches++;
            } else if (j == TestEnum.FOURTH.ordinal()) {
                matches++;
            } else if (j == TestEnum.FIFTH.ordinal()) {
                matches++;
            } else if (j == TestEnum.SIXTH.ordinal()) {
                matches++;
            } else if (j == TestEnum.SEVENTH.ordinal()) {
                matches++;
            } else if (j == TestEnum.EIGHTH.ordinal()) {
                matches++;
            } else if (j == TestEnum.NINTH.ordinal()) {
                matches++;
            } else {
                matches++;
            }
        }
        System.out.println("If / else took "+(System.currentTimeMillis() - time)+" ms");
        time = System.currentTimeMillis();
        for (int i = 0; i < LOOP; i++) {
            TestEnum te = TestEnum.values()[r.nextInt(SIZE)];
            switch (te.ordinal()) {
                case 0:
                    matches++;
                    break;
                case 1:
                    matches++;
                    break;
                case 2:
                    matches++;
                    break;
                case 3:
                    matches++;
                    break;
                case 4:
                    matches++;
                    break;
                case 5:
                    matches++;
                    break;
                case 6:
                    matches++;
                    break;
                case 7:
                    matches++;
                    break;
                case 8:
                    matches++;
                    break;
                case 9:
                    matches++;
                    break;
                default:
                    matches++;
                    break;
            }
        }
        System.out.println("Switch took "+(System.currentTimeMillis() - time)+" ms");
        time = System.currentTimeMillis();
        for (int i = 0; i < LOOP; i++) {
            TestEnum te = TestEnum.values()[r.nextInt(SIZE)];
            switch (te) {
                case FIRST:
                    matches++;
                    break;
                case SECOND:
                    matches++;
                    break;
                case THIRD:
                    matches++;
                    break;
                case FOURTH:
                    matches++;
                    break;
                case FIFTH:
                    matches++;
                    break;
                case SIXTH:
                    matches++;
                    break;
                case SEVENTH:
                    matches++;
                    break;
                case EIGHTH:
                    matches++;
                    break;
                case NINTH:
                    matches++;
                    break;
                default:
                    matches++;
                    break;
            }
        }
        System.out.println("Switch 2 took "+(System.currentTimeMillis() - time)+" ms");     
        System.out.println("Total matches: "+matches);
    }
}

ওয়েল, ঠিক আছে তবে .. বাস্তব সত্যটি হ'ল যে কোনও বাস্তব ব্যবহারের ক্ষেত্রে এই কোডিং বিকল্পগুলির মধ্যে পার্থক্য এতটাই ছোট যে কোনও বাস্তব প্রয়োগে, তাদের মধ্যে পারফরম্যান্সের পার্থক্য সম্ভবত খুব অল্পই ছোট হবে। আপনার কোডটি প্রথমে সঠিক করুন এবং তারপরে (কেবল তখনই) এটি দ্রুত করুন (যদি এটির দ্রুত হওয়া দরকার)।
স্কটব

সম্মত, তবে মূল প্রশ্নটি ছিল দ্রুততম, সবচেয়ে কার্যকর উপায়ে। অনেকগুলি স্টাইল রয়েছে যা কোড পড়া বা বজায় রাখতে অসুবিধা সৃষ্টি করে তবে আরও কার্যকর, যদিও সাধারণত ভবিষ্যতের কোনও সময়ে সংকলক অনুকূলিতকরণগুলি দ্বারা এগুলি সমাধান করা হয়। এর একটি উদাহরণ হ'ল intern()স্ট্রিংগুলির ব্যবহার যা জাভার বেশিরভাগ আধুনিক সংস্করণে এখন আর প্রয়োজন হয় না।
মার্কাস

সম্মত, তবে অন্যথায় এবং যদি স্যুইচ-কেস ব্লকগুলি হয় তবে যে কোনও ক্ষেত্রে রক্ষণাবেক্ষণ, দৃness়তা এবং পঠনযোগ্যতার সমস্যাগুলির দুর্বল সমাধান। আপনার মালিকানাধীন এনামগুলির জন্য (বা যার কোডটি আপনি সংশোধন করতে পারেন) সবচেয়ে ভাল অনুশীলনটি প্রায়শই একটি সমৃদ্ধ এনাম ধরণের ধ্রুবক-নির্দিষ্ট পদ্ধতি ব্যবহার করা হয়, বেশিরভাগ সময় এনামটি স্যুইচিংয়ের সাথে দেখা উচিত কারণ আরও ভাল রয়েছে সমাধান সেখানে।
স্কটব

1

যারা-যদি অন্য-জাল সমাধানটি বেছে নিয়েছেন তাদের জন্য, দয়া করে ব্যবহার করুন:

String columnName = metadata.getColumnName(
String displayName = metadata.getColumnLabel(i);
switch (metadata.getColumnType(i)) {
case Types.ARRAY:
    obj.put(displayName, resultSet.getArray(columnName));
    break;
...

কারণ আপনার ক্যোয়ারিতে উপস্বের ক্ষেত্রে কলামের নাম এবং কলামের লেবেল দুটি আলাদা জিনিস। উদাহরণস্বরূপ যদি আপনি নির্বাহ করেন:

select col1, col2 as my_alias from table

তুমি পাবে

[
    { "col1": 1, "col2": 2 }, 
    { "col1": 1, "col2": 2 }
]

বরং:

[
    { "col1": 1, "my_alias": 2 }, 
    { "col1": 1, "my_alias": 2 }
]

0
package com.idal.cib;

import java.io.FileWriter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

public class DBJsonConverter {

    static ArrayList<String> data = new ArrayList<String>();
    static Connection conn = null;
    static PreparedStatement ps = null;
    static ResultSet rs = null;
    static String path = "";
    static String driver="";
    static String url="";
    static String username="";
    static String password="";
    static String query="";

    @SuppressWarnings({ "unchecked" })
    public static void dataLoad(String path) {
        JSONObject obj1 = new JSONObject();
        JSONArray jsonArray = new JSONArray();
        conn = DatabaseConnector.getDbConnection(driver, url, username,
                password);
        try {
            ps = conn.prepareStatement(query);
            rs = ps.executeQuery();
            ArrayList<String> columnNames = new ArrayList<String>();
            if (rs != null) {
                ResultSetMetaData columns = rs.getMetaData();
                int i = 0;
                while (i < columns.getColumnCount()) {
                    i++;
                    columnNames.add(columns.getColumnName(i));
                }
                while (rs.next()) {
                    JSONObject obj = new JSONObject();
                    for (i = 0; i < columnNames.size(); i++) {
                        data.add(rs.getString(columnNames.get(i)));
                        {
                            for (int j = 0; j < data.size(); j++) {
                                if (data.get(j) != null) {
                                    obj.put(columnNames.get(i), data.get(j));
                                }else {
                                    obj.put(columnNames.get(i), "");
                                }
                            }
                        }
                    }

                    jsonArray.add(obj);
                    obj1.put("header", jsonArray);
                    FileWriter file = new FileWriter(path);
                    file.write(obj1.toJSONString());
                    file.flush();
                    file.close();
                }
                ps.close();
            } else {
                JSONObject obj2 = new JSONObject();
                obj2.put(null, null);
                jsonArray.add(obj2);
                obj1.put("header", jsonArray);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                    rs.close();
                    ps.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    @SuppressWarnings("static-access")
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        driver = "oracle.jdbc.driver.OracleDriver";
        url = "jdbc:oracle:thin:@localhost:1521:database";
        username = "user";
        password = "password";
        path = "path of file";
        query = "select * from temp_employee";

        DatabaseConnector dc = new DatabaseConnector();
        dc.getDbConnection(driver,url,username,password);
        DBJsonConverter formatter = new DBJsonConverter();
        formatter.dataLoad(path);

    }

}




package com.idal.cib;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnector {

    static Connection conn1 = null;

    public static Connection getDbConnection(String driver, String url,
            String username, String password) {
        // TODO Auto-generated constructor stub
        try {

            Class.forName(driver);

            conn1 = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn1;
    }

}

Pl আপনার উত্তরে কিছু ব্যাখ্যা যুক্ত করুন।
সাহিল মিত্তাল

0
public static JSONArray GetJSONDataFromResultSet(ResultSet rs) throws SQLException {
    ResultSetMetaData metaData = rs.getMetaData();
    int count = metaData.getColumnCount();
    String[] columnName = new String[count];
    JSONArray jsonArray = new JSONArray();
    while(rs.next()) {
        JSONObject jsonObject = new JSONObject();
        for (int i = 1; i <= count; i++){
               columnName[i-1] = metaData.getColumnLabel(i);
               jsonObject.put(columnName[i-1], rs.getObject(i));
        }
        jsonArray.put(jsonObject);
    }
    return jsonArray;
}

-1

অন্য উপায়ে, আমি এখানে অ্যারেলিস্ট এবং মানচিত্র ব্যবহার করেছি, সুতরাং এটি সারি দ্বারা জসন অবজেক্টকে সারি বলবে না তবে ফলাফলের পুনরাবৃত্তি শেষ হওয়ার পরে:

 List<Map<String, String>> list = new ArrayList<Map<String, String>>();

  ResultSetMetaData rsMetaData = rs.getMetaData();  


      while(rs.next()){

              Map map = new HashMap();
              for (int i = 1; i <= rsMetaData.getColumnCount(); i++) {
                 String key = rsMetaData.getColumnName(i);

                  String value = null;

               if (rsmd.getColumnType(i) == java.sql.Types.VARCHAR) {
                           value = rs.getString(key);
               } else if(rsmd.getColumnType(i)==java.sql.Types.BIGINT)                         
                             value = rs.getLong(key);
               }                  


                    map.put(key, value);
              }
              list.add(map);


    }


     json.put(list);    
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.