😋 ☔️ 🈳 DIY माइक्रो- ORM (भाग एक) 👶🏼 👐🏾 🤜🏾

इस लाइब्रेरी को लिखने के लिए मुझे क्या प्रेरित किया गया और क्यों मौजूदा समाधान खराब हैं:
दुर्भाग्य से, हाइबरनेट जैसे राक्षस "हैवीवेट" हैं और डेटाबेस के साथ काम करने के लिए अपना स्वयं का एपीआई लगाते हैं। मुझे एक साधारण पुस्तकालय की आवश्यकता थी जिसे नियमित JDBC कोड के साथ मिश्रित किया जा सके (वास्तव में, मुझे JDBC के लिए किसी प्रकार के Dapper.NET की आवश्यकता थी)।

पुस्तकालय लिखने में उपयोग किए जाने वाले मूल सिद्धांत:

सादगी और परमाणु - पुस्तकालय 1 जावा-फ़ाइल है, परियोजना में जोड़ने के लिए बस अपने स्रोत में एक फ़ाइल जोड़ें।
गैर-घुसपैठ - पुस्तकालय अपने एपीआई को लागू नहीं करता है, नियमित JDBC कोड के साथ "मिश्रण" का उपयोग करना संभव है
स्वतंत्रता - पुस्तकालय जावा एसई 5 के अलावा कुछ भी नहीं उपयोग करता है
एक्स्टेंसिबिलिटी - लाइब्रेरी एक विशिष्ट परियोजना के लिए आवश्यक एक्सटेंशन जोड़ने का समर्थन करती है

मापदंडों के एक भरे हुए संग्रह के साथ रेडीस्टेडमेंट बनाने के लिए विधि का कार्यान्वयन।

मैं इस तरह का कोड लिखना चाहूंगा:

PreparedStatement stmt = DB.prepareStatement(conn, "select id, login, email from users where (login={0} or email={0}) and pass={1}", "dimzon", "pass")

यहां पैरामीटर मानों को अलग-अलग पारित किया जाता है और अनुरोध निकाय में {PARAMETER_ INDEX} निर्माण का उपयोग करके उन्हें संदर्भित किया जाता है। इस तरह के एक रिकॉर्ड संक्षिप्त और सुविधाजनक है (और .NET प्रोग्रामर से परिचित)।
इस प्रकार, हमारे पास निम्नलिखित विधि घोषणा है:

 public static PreparedStatement prepareStatement(Connection cn, CharSequence query, Object... args) throws SQLException

कार्यान्वयन में 2 समस्याओं को हल करना शामिल है:

{PARAMETER_ INDEX} निर्माण की प्रविष्टि के लिए अनुरोध निकाय की जगह, "?" और मैपिंग "आर्गन्स में इंडेक्स -> रेडीएटमेंट में सूचकांकों की सरणी"
उपयुक्त सेटएक्सएक्सएक्सएक्सएक्स तरीकों को कॉल करके रेडीस्टेडमेंट में मापदंडों का प्रतिस्थापन

नियमित अभिव्यक्ति का उपयोग करके पहली समस्या हल की जाती है। और दूसरी समस्या को हल करते समय, बारीकियां उत्पन्न होती हैं:

एसक्यूएल पैरामीटर के प्रकार का निर्धारण। सरल मामलों (पूर्णांक, तिथि) के लिए, सब कुछ सरल है, लेकिन यह स्पष्ट नहीं है कि अगर कुछ गैर-मानक वर्ग एक तर्क के रूप में पारित किया गया था तो क्या करना चाहिए।
अशक्त मूल्यों की व्याख्या। Java में, null unyped है (अर्थात आप null.getClass () नहीं कर सकते हैं) - यह स्पष्ट नहीं है कि किस java.sql.Types को PassedStatement.setNull में पास करना है।

दोनों समस्याओं को हल करने में, "रणनीति" पैटर्न हमारी मदद करेगा:

 public interface Param { void set(PreparedStatement ps, int index) throws SQLException; }

जीवन आसान हो गया है - यदि हमारे पास इनपुट पर परम इंटरफ़ेस का कार्यान्वयन है, तो हम बस सेट विधि को कहते हैं। मानक मामलों (पूर्णांक, तिथि), एकरूपता के लिए, हम रणनीतियों के माध्यम से भी परिचय देंगे। इसलिए हमें पैरामीटर के प्रकार (यदि यह शुरू में रणनीति नहीं है) के आधार पर सही रणनीति बनाने की एक विधि की आवश्यकता है।
यहाँ "फ़ैक्टरी" पैटर्न हमारी मदद करेगा। लेकिन मैंने कारखाने के लिए एक अलग इंटरफ़ेस शुरू नहीं किया है, मैंने निम्नलिखित सार वर्ग लिखा है (.NET प्रोग्रामर Func <T, R>) के साथ एक एनालॉग देखेंगे।

 public static abstract class FN<I,O> { public abstract O apply(I input) throws Exception; }

इस प्रकार, कारखाना वर्ग एफएन <ऑब्जेक्ट, परम> का एक वंशज है।
जल्दी से एक कारखाने का उदाहरण प्राप्त करने के लिए, समवर्ती हाशपा <क्लास, एफएन <ऑब्जेक्ट, परम >> पैरामैप्टरीज का उपयोग करें।
यदि हम अपने कारखाने को इस मानचित्र में जोड़ते हैं, तो हम अपनी कक्षा उत्तीर्ण कर सकते हैं जैसा कि तैयारी के लिए है - 1 और विधि दिखाई देती है:

 public static <E> void registerParamFactory(Class<E> forClass, FN<E, Param> factory)

तदनुसार, एक गैर-मानक स्थिति (एक्स्टेंसिबिलिटी) के लिए, दो दृष्टिकोणों में से एक को लागू किया जा सकता है:

स्पष्ट रूप से तैयार करने के लिए परम के अपने कार्यान्वयन को पास करें
रजिस्टरप्रेमफैक्ट्री के साथ परम निर्माण कारखाना पंजीकृत करें

आखिरी सवाल यह है कि क्या करना है अगर तैयारी स्टालमेंट शून्य के साथ आए। प्रकार निर्धारित नहीं किया जा सकता है, लेकिन अगर इसके बजाय "?" सीधे अनुरोध निकाय में "NULL" डालें, फिर सर्वर इसका पता लगाएगा।

इस उदाहरण के लिए पूर्ण कोड:

 package a.poor.mans.orm.part1; import javax.xml.bind.JAXB; import java.io.IOException; import java.io.StringWriter; import java.sql.*; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; public class DB { public interface Param { void set(PreparedStatement preparedStatement, int index) throws SQLException; } public static abstract class FN<I, O> { public abstract O apply(I input) throws Exception; public static <I, O> FN<I, O> constant(final O constValue) { return new FN<I, O>() { public O apply(I input) throws Exception { return constValue; } }; } } public static Param paramDate(final Date value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setDate(index, value); else preparedStatement.setNull(index, Types.DATE); } }; } public static Param paramTime(final Time value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setTime(index, value); else preparedStatement.setNull(index, Types.TIME); } }; } public static Param paramTimestamp(final Timestamp value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setTimestamp(index, value); else preparedStatement.setNull(index, Types.TIMESTAMP); } }; } public static Param paramString(final String value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { preparedStatement.setString(index, value); } }; } public static Param paramInteger(final Integer value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setInt(index, value); else preparedStatement.setNull(index, Types.INTEGER); } }; } public static Param paramLong(final Long value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setLong(index, value); else preparedStatement.setNull(index, Types.BIGINT); } }; } public static Param paramShort(final Short value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setShort(index, value); else preparedStatement.setNull(index, Types.SMALLINT); } }; } public static Param paramByte(final Byte value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) preparedStatement.setByte(index, value); else preparedStatement.setNull(index, Types.TINYINT); } }; } public static Param paramXML(final String value) { return new Param() { SQLXML sqlxml = null; public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value != null) { if (sqlxml == null) { sqlxml = preparedStatement.getConnection().createSQLXML(); sqlxml.setString(value); } preparedStatement.setSQLXML(index, sqlxml); } else { preparedStatement.setNull(index, Types.SQLXML); } } }; } public static Param paramXML(final SQLXML value) { return new Param() { public void set(PreparedStatement preparedStatement, int index) throws SQLException { if (value == null) preparedStatement.setNull(index, Types.SQLXML); else preparedStatement.setSQLXML(index, value); } }; } private final static Pattern INDEX_PATTERN = Pattern.compile("((?<!\\{)\\{)(\\d+)(\\}(?!\\}))"); private final static Pattern ESCAPE_OPEN = Pattern.compile("\\{\\{"); private final static Pattern ESCAPE_CLOSE = Pattern.compile("}}", Pattern.LITERAL); private static String object2xml(Object obj) { StringWriter stringWriter = new StringWriter(); try { try { JAXB.marshal(obj, stringWriter); } finally { stringWriter.close(); } return stringWriter.toString(); } catch (IOException e) { throw new RuntimeException(e.toString(), e); } } private final static Map<Class, FN> paramFactories = new ConcurrentHashMap<Class, FN>() { { put(SQLXML.class, new FN<SQLXML, Param>() { public Param apply(SQLXML input) throws Exception { return paramXML(input); } }); put(Collection.class, new FN<Collection, Param>() { public Param apply(Collection input) throws Exception { return paramXML(object2xml(input.toArray())); } }); put(String.class, new FN<String, Param>() { public Param apply(String input) throws Exception { return paramString(input); } }); put(java.sql.Date.class, new FN<java.sql.Date, Param>() { public Param apply(java.sql.Date input) throws Exception { return paramDate(input); } }); put(Time.class, new FN<Time, Param>() { public Param apply(Time input) throws Exception { return paramTime(input); } }); put(Timestamp.class, new FN<Timestamp, Param>() { public Param apply(Timestamp input) throws Exception { return paramTimestamp(input); } }); put(Boolean.class, emptyFN); put(Long.class, emptyFN); put(Integer.class, emptyFN); put(Short.class, emptyFN); put(byte.class, emptyFN); } }; public static <E> void registerParamFactory(Class<E> forClass, FN<E, Param> factory) { paramFactories.put(forClass, factory); for (Map.Entry<Class, FN> pair : paramFactories.entrySet()) { if (pair.getValue() == emptyFN) pair.setValue(null); } } private static FN getParamFactory(Class paramClass) { FN v = getParamFactory(paramClass, paramClass); if (v != null) return v; paramFactories.put(paramClass, emptyFN); return emptyFN; } private static FN getParamFactory(Class paramClass, Class targetClass) { FN val; for (Class current = paramClass; current != Object.class && current != null; current = current.getSuperclass()) { val = paramFactories.get(current); if (val != null) { if (current != targetClass) paramFactories.put(targetClass, val); return val; } for (Class intf : current.getInterfaces()) { val = getParamFactory(intf, targetClass); if (val != null) return val; } } return null; } private static final FN emptyFN = new FN() { public Object apply(Object input) throws Exception { return null; } }; @SuppressWarnings("unchecked") public static PreparedStatement prepareStatement(final Connection connection, final CharSequence query, final Object... args) throws SQLException { int argc = args.length; String[] strings = new String[argc]; Param[] params = new Param[argc]; Object[] indexes = new Object[argc]; for (int i = 0; i < argc; ++i) { Object arg = args[i]; if (null == arg) { strings[i] = "NULL"; } else if (arg instanceof Param) { params[i] = (Param) arg; } else { Class paramClass = arg.getClass(); FN factory = getParamFactory(paramClass); if (factory != null && factory != emptyFN) { try { params[i] = (Param) factory.apply(arg); } catch (Exception e) { throw new RuntimeException(e); } } else { if (arg instanceof Boolean) { strings[i] = ((Boolean) arg) ? "1" : "0"; } else if (arg instanceof Integer) { strings[i] = Integer.toString((Integer) arg); } else if (arg instanceof Long) { strings[i] = Long.toString((Long) arg); } else if (arg instanceof Short) { strings[i] = Short.toString((Short) arg); } else if (arg instanceof Byte) { strings[i] = Byte.toString((Byte) arg); } else { params[i] = paramXML(object2xml(arg)); } } } } Matcher matcher = INDEX_PATTERN.matcher(query); StringBuffer stringBuffer = new StringBuffer(); int index = 0; while (matcher.find()) { ++index; int reference = Integer.parseInt(matcher.group(2)); if (strings[reference] != null) { matcher.appendReplacement(stringBuffer, strings[reference]); } else { List<Integer> lst = (List<Integer>) (null == indexes[reference] ? (indexes[reference] = new ArrayList<Integer>()) : indexes[reference]); lst.add(index); matcher.appendReplacement(stringBuffer, "?"); } } matcher.appendTail(stringBuffer); String sql = ESCAPE_CLOSE.matcher(ESCAPE_OPEN.matcher(stringBuffer).replaceAll("{")).replaceAll("}"); PreparedStatement preparedStatement = connection.prepareStatement(sql); for (int i = 0; i < argc; ++i) { List<Integer> lst = (List<Integer>) indexes[i]; if (lst == null) continue; Param param = params[i]; for (Integer pos : lst) param.set(preparedStatement, pos); } return preparedStatement; } public static ResultSet executeQuery(final Connection connection, final CharSequence query, final Object... args) throws SQLException { PreparedStatement preparedStatement = prepareStatement(connection, query, args); try { return preparedStatement.executeQuery(); } finally { preparedStatement.close(); } } public static boolean execute(final Connection connection, final CharSequence query, final Object... args) throws SQLException { PreparedStatement preparedStatement = prepareStatement(connection, query, args); try { return preparedStatement.execute(); } finally { preparedStatement.close(); } } public static int executeUpdate(final Connection connection, final CharSequence query, final Object... args) throws SQLException { PreparedStatement preparedStatement = prepareStatement(connection, query, args); try { return preparedStatement.executeUpdate(); } finally { preparedStatement.close(); } } }

DIY माइक्रो- ORM (भाग एक)

मापदंडों के एक भरे हुए संग्रह के साथ रेडीस्टेडमेंट बनाने के लिए विधि का कार्यान्वयन।

More articles: