7.1 కనెక్షన్ పూల్
ఈ రోజు మనం డేటాబేస్‌తో మరింత ప్రొఫెషనల్‌గా ఎలా పని చేయాలో నేర్చుకుంటాము. ఇప్పుడు మనం ఆంగ్లంలో థ్రెడ్ పూల్ లేదా కనెక్షన్ పూల్ గురించి మాట్లాడుతాము .
డేటాబేస్కు కనెక్ట్ చేయడానికి కొంత సమయం పడుతుంది. ముఖ్యంగా డేటాబేస్ రిమోట్‌గా ఉంటే. మేము ప్రతి అభ్యర్థన కోసం డేటాబేస్కు కనెక్షన్ చేస్తే, మా అప్లికేషన్ యొక్క ప్రతిస్పందన వేగంలో చాలా నెమ్మదిగా ఉంటుంది. అది వినియోగించే వనరుల గురించి ప్రత్యేకంగా చెప్పనక్కర్లేదు.
అటువంటి సమస్యలకు పరిష్కారంగా, థ్రెడ్ పూల్ అని పిలువబడే కొన్ని సెట్లలో బేస్కు కనెక్షన్లను నిల్వ చేయడానికి ప్రతిపాదించబడింది.
మేము కొత్త కనెక్షన్‌ని అభ్యర్థించినప్పుడు, కనెక్షన్ పూల్ దానిని సృష్టిస్తుంది మరియు మూసివేసినప్పుడు, అది దాన్ని మూసివేయదు, కానీ కనెక్షన్ పూల్‌లో సేవ్ చేస్తుంది. మరియు మేము కనెక్షన్ పూల్ నుండి మళ్లీ కనెక్షన్‌ని అభ్యర్థిస్తే, అది కొత్తదాన్ని సృష్టించే బదులు పాతవాటిలో ఒకదాన్ని ఇస్తుంది.
వాస్తవానికి, అప్లికేషన్ ప్రత్యేక డ్రైవర్ ద్వారా పని చేస్తుంది, ఇది సాధారణ JDBC డ్రైవర్‌కు రేపర్ మరియు పూల్‌తో పని చేయడానికి అదనపు కార్యాచరణను కలిగి ఉంటుంది. ఈ పరిస్థితిని ఈ క్రింది విధంగా సూచించవచ్చు:
ప్రోగ్రామర్ కనెక్షన్ పూల్ కోసం సెట్టింగ్‌లను మాన్యువల్‌గా సెట్ చేయవచ్చు: సక్రియ కనెక్షన్‌ల సంఖ్య, గడువు ముగియడం మొదలైనవి.
ముఖ్యంగా తీవ్రమైన పరిస్థితుల కోసం, మీరు మీ స్వంత కనెక్షన్ పూల్‌ను వ్రాయవచ్చు: కనెక్షన్‌ల జాబితాను కలిగి ఉండే తరగతి. ఇది క్లోజ్ ఫంక్షన్‌ను ఓవర్‌రైడ్ చేస్తుంది, ఇది కనెక్షన్‌ని తిరిగి జాబితాకు తిరిగి ఇస్తుంది మరియు ఓపెన్ కనెక్షన్ టైమర్ వంటి అనేక ఇతర గూడీస్ ఉంటాయి. ఎక్కువ కాలం కనెక్షన్ లేనప్పుడు, కనెక్షన్ మూసివేయబడుతుంది.
7.2* ఇంటర్‌ఫేస్ డేటాసోర్స్ మరియు కనెక్షన్‌పూల్‌డేటాసోర్స్
థ్రెడ్ పూల్ సాధారణంగా డేటాసోర్స్ ఆబ్జెక్ట్‌తో కలిసి పని చేస్తుంది. ఈ వస్తువును రిమోట్ డేటాబేస్ యొక్క సంగ్రహణగా భావించవచ్చు. డేటా సోర్స్ అనే పేరును అక్షరాలా డేటా సోర్స్ అని అనువదించవచ్చు. ఇది ఒక రకమైన సూచన.
డేటాబేస్కు భౌతిక కనెక్షన్‌ని పొందడానికి డేటాసోర్స్ ఆబ్జెక్ట్‌లు ఉపయోగించబడతాయి మరియు అవి DriverManagerకి ప్రత్యామ్నాయం. JDBC డ్రైవర్‌ను నమోదు చేయవలసిన అవసరం లేదు. మీరు కనెక్షన్‌ని స్థాపించడానికి తగిన పారామితులను మాత్రమే సెట్ చేయాలి మరియుgetConnection() పద్ధతిని అమలు చేయండి.
డేటాసోర్స్ రకం యొక్క వస్తువును స్థానికంగా (నేరుగా అప్లికేషన్‌లో) సృష్టించేటప్పుడు, JDBC డ్రైవర్ ప్రొవైడర్ అందించిన తగిన పద్ధతుల ద్వారా కనెక్షన్ పారామితులు సెట్ చేయబడతాయి. ఈ పద్ధతులు DataSource ఇంటర్‌ఫేస్ ద్వారా నిర్వచించబడలేదు, ఎందుకంటే వివిధ విక్రేతల నుండి DBMSకి కనెక్ట్ చేసే పారామితులు రకం మరియు సంఖ్య రెండింటిలోనూ తేడా ఉండవచ్చు (ఉదాహరణకు, అన్ని DBMSకి డ్రైవర్ లేదా నెట్‌వర్క్ ప్రోటోకాల్ రకం పేర్కొనవలసిన అవసరం లేదు).
అందువలన, Oracle DBMSతో పని చేస్తున్నప్పుడు, సంబంధిత సెట్‌ను ఉపయోగించడానికి మరియు పద్ధతులను పొందడానికి, OracleDataSource రకం యొక్క వస్తువును పొందడం అవసరం, ఇది డేటాసోర్స్ ఇంటర్‌ఫేస్‌ను అమలు చేసే అదే పేరుతో ఉన్న తరగతికి ఉదాహరణ. అందువల్ల, డేటాసోర్స్ రకం వస్తువులను సృష్టించే ఈ మార్గం మీ కోడ్‌ను తక్కువ పోర్టబుల్‌గా చేస్తుంది మరియు డ్రైవర్ యొక్క నిర్దిష్ట అమలుపై తక్కువ ఆధారపడి ఉంటుంది.
డేటాసోర్స్ రకం వస్తువుల స్థానిక ఉపయోగాన్ని వివరించే కోడ్ ఉదాహరణ క్రిందిది.
import java.sql.*;
import javax.sql.*;
import oracle.jdbc.driver.*;
import oracle.jdbc.pool.*;
public class DataSource {
public static void main(String[] args) {
try {
OracleDataSource ods = new OracleDataSource();
ods.setUser("root");
ods.setPassword("secret");
ods.setDriverType("thin");
ods.setDatabaseName("test");
ods.setServerName("localhost");
ods.setPortNumber(1521);
Connection connection = ods.getConnection();
System.out.println("Connection successful!!!");
} catch (SQLException se) {
se.printStackTrace();
}
System.out.println("Goodbye!");
}
}7.3* JNDI ఇంటర్‌ఫేస్
డేటాసోర్స్ రకం వస్తువుల పూర్తి సామర్థ్యాలు JNDI ఇంటర్‌ఫేస్‌తో కలిపి వ్యక్తీకరించబడతాయి. JNDI అనేది పెద్ద సర్వర్ అప్లికేషన్‌ల కోసం ఒక ప్రత్యేక సేవ (డైరెక్టరీ లాంటిది), ఇది ఒక సేవను మరొక దానితో కనెక్షన్‌ని ఏర్పరచుకోవడానికి అనుమతిస్తుంది.
పేరు మరియు డైరెక్టరీ సేవను ఉపయోగించడం వలన సిస్టమ్ అడ్మినిస్ట్రేటర్ గతంలో రూపొందించిన డేటాసోర్స్ రకం వస్తువులను ముందే నిర్వచించిన కనెక్షన్ పారామితులతో నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. సన్ అభివృద్ధి చేసిన కొన్ని ప్రామాణిక ఆస్తి (పారామీటర్) పేర్లు క్రిందివి:
| ఆస్తి పేరు | జావా డేటా రకం | ప్రయోజనం |
|---|---|---|
| డేటాబేస్ పేరు | స్ట్రింగ్ | డేటాబేస్ పేరు |
| సర్వర్ పేరు | స్ట్రింగ్ | సర్వర్ పేరు |
| వినియోగదారు | స్ట్రింగ్ | వినియోగదారు పేరు (ID) |
| పాస్వర్డ్ | స్ట్రింగ్ | వినియోగదారు పాస్వర్డ్ |
| పోర్ట్ నంబర్ | int | DBMS సర్వర్ పోర్ట్ నంబర్ |
J2EE కాంపోనెంట్ టెక్నాలజీ ఆధారంగా బహుళ-స్థాయి ఎంటర్‌ప్రైజ్ అప్లికేషన్‌ల అభివృద్ధిలో డేటాసోర్స్ మరియు JNDI ఇంటర్‌ఫేస్‌ల కలయిక కీలక పాత్ర పోషిస్తుంది.
మీరు మీ అప్లికేషన్ కోడ్‌లో డేటాసోర్స్ మరియు JNDI ఇంటర్‌ఫేస్‌ల కలయికను ఉపయోగిస్తే, మీరు పేరు పెట్టడం మరియు డైరెక్టరీ సేవ నుండి డేటాసోర్స్ రకం వస్తువును మాత్రమే అభ్యర్థించాలి. ఈ సందర్భంలో, కనెక్షన్ యొక్క వివరాలు మరియు డ్రైవర్ యొక్క నిర్దిష్ట అమలుపై ఆధారపడిన ప్రోగ్రామ్ కోడ్ పేరు మరియు డైరెక్టరీ సేవలో నిల్వ చేయబడిన వస్తువులోని అప్లికేషన్ నుండి దాచబడతాయి.
అందువల్ల, డేటాసోర్స్ మరియు JNDI రకం వస్తువుల భాగస్వామ్యం ఒకదానికొకటి స్వతంత్రంగా నిర్వహించబడే రెండు దశలను కలిగి ఉంటుంది:
Context.bind()మీరు తప్పనిసరిగా పేరు పెట్టడం మరియు డైరెక్టరీ సేవలో డేటాసోర్స్ రకం యొక్క పేరు పెట్టబడిన వస్తువును తప్పనిసరిగా నిల్వ చేయాలిjavax.naming.- ఉపయోగించి అప్లికేషన్‌లోని నామకరణ మరియు డైరెక్టరీ సేవ నుండి డేటాసోర్స్ రకం వస్తువును అభ్యర్థించండి
Context.lookup().DataSource.getConnection()ఆ తర్వాత, మీరు డేటాబేస్కు కనెక్షన్ పొందడానికి దాని పద్ధతిని ఉపయోగించవచ్చు .
కిందిది JNDI ఇంటర్‌ఫేస్ మరియు OracleDataSource రకం వస్తువును కలిపి ఉపయోగించేందుకు ఒక ఉదాహరణ.
// Create a key JNDI object
Hashtable env = new Hashtable();
env.put (Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
env.put (Context.PROVIDER_URL, "file:JNDI");
Context ctx = new InitialContext(env);
// Get the DataSource object by its name
DataSource ods = (DataSource) ctx.lookup("myDatabase");
// Get the Connection from the DataSource object
Connection connection = ods.getConnection();
System.out.println("Connection successful!!!");మేము JNDI యొక్క పనిని విశ్లేషించము. ఇది ఈ కోర్సు పరిధికి వెలుపల ఉంది. పెద్ద అప్లికేషన్లలో ఈ విధానం చాలా సాధారణం అని మీరు తెలుసుకోవాలని నేను కోరుకుంటున్నాను. మీరు భవిష్యత్తులో ఇలాంటి కోడ్‌ని చూసినట్లయితే కోల్పోకండి.
ఇది ఎలా పని చేస్తుందో పట్టింపు లేదు. JNDI సేవతో మీరు సేవా డైరెక్టరీలో నమోదు చేయబడిన ఏదైనా సేవ యొక్క ప్రాక్సీ వస్తువును పొందవచ్చని మీరు తెలుసుకోవాలి. ఈ విధంగా మీరు డేటాసోర్స్ ఆబ్జెక్ట్‌ని పొందండి మరియు డేటాబేస్‌తో పని చేయడానికి దాన్ని ఉపయోగించండి.
7.4 కనెక్షన్ పూల్ ఉదాహరణలు
మేము ప్రారంభించిన ప్రదేశానికి తిరిగి వెళ్దాం - కనెక్షన్ పూల్స్.
జావా ప్రోగ్రామర్లు వారి ప్రోగ్రామ్‌లలో చాలా తరచుగా కనెక్షన్ పూల్స్ యొక్క వివిధ అమలులను కలిగి ఉన్న లైబ్రరీలను ఉపయోగిస్తారు. వాటిలో మూడు అత్యంత ప్రసిద్ధమైనవి:
- అపాచీ కామన్స్ DBCP
- C3PO
- హికారిసీపీ
అపాచీ ప్రాజెక్ట్ మంచి కనెక్షన్ పూల్‌ను రూపొందించిన మొదటిది, ఇది టామ్‌క్యాట్ వెబ్ సర్వర్‌లో కూడా ఉపయోగించబడుతుంది. దానితో పని చేయడానికి ఒక ఉదాహరణ:
public class DBCPDataSource {
private static BasicDataSource ds = new BasicDataSource();
static {
ds.setUrl("jdbc:h2:mem:test");
ds.setUsername("user");
ds.setPassword("password");
ds.setMinIdle(5);
ds.setMaxIdle(10);
ds.setMaxOpenPreparedStatements(100);
}
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
private DBCPDataSource(){ }
}రెండవ అత్యంత ప్రజాదరణ పొందిన పూల్ C3PO . వింత పేర్లు, నేను అంగీకరిస్తున్నాను. C3PO అనే పేరు స్టార్ వార్స్ నుండి వచ్చిన c3po రోబోట్‌కు సూచన. అలాగే CP అనేది కనెక్షన్ పూల్‌కి సంక్షిప్త పదం.
public class C3p0DataSource {
private static ComboPooledDataSource cpds = new ComboPooledDataSource();
static {
try {
cpds.setDriverClass("org.h2.Driver");
cpds.setJdbcUrl("jdbc:h2:mem:test");
cpds.setUser("user");
cpds.setPassword("password");
} catch (PropertyVetoException e) {
// handle the exception
}
}
public static Connection getConnection() throws SQLException {
return cpds.getConnection();
}
private C3p0DataSource(){}
}దానికి సంబంధించిన డాక్యుమెంటేషన్ అధికారిక పేజీలో చూడవచ్చు .
చివరకు, మన కాలంలో అత్యంత ప్రజాదరణ పొందిన కనెక్షన్ పూల్ HikariCP :
public class HikariCPDataSource {
private static HikariConfig config = new HikariConfig();
private static HikariDataSource ds;
static {
config.setJdbcUrl("jdbc:h2:mem:test");
config.setUsername("user");
config.setPassword("password");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
ds = new HikariDataSource(config);
}
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
private HikariCPDataSource(){}
}అతని అధికారిక GitHub పేజీ ఇక్కడ ఉంది .
మరియు ఆకృతీకరణపై మంచి వ్యాసం .
GO TO FULL VERSION