spring-boot
एक स्प्रिंग-बूट एप्लिकेशन को MySQL से कनेक्ट करना

परिचय

टिप्पणियों

MySQL का उपयोग करके स्प्रिंग-बूट नमूना

हम स्प्रिंग-बूट और स्प्रिंग-डेटा-जपा के लिए आधिकारिक गाइड का पालन करेंगे। हम एंगल का उपयोग करके एप्लिकेशन का निर्माण करेंगे।

1. ग्रेड बिल्ड फ़ाइल बनाएँ

   build.gradle

   buildscript {
       repositories {
           mavenCentral()
       }
       dependencies {
           classpath("org.springframework.boot:spring-boot-gradle-plugin:1.4.3.RELEASE")
       }
   }
   
   apply plugin: 'java'
   apply plugin: 'eclipse'
   apply plugin: 'idea'
   apply plugin: 'org.springframework.boot'
   
   jar {
       baseName = 'gs-accessing-data-jpa'
       version =  '0.1.0'
   }
   
   repositories {
       mavenCentral()
       maven { url "https://repository.jboss.org/nexus/content/repositories/releases" }
   }
   
   sourceCompatibility = 1.8
   targetCompatibility = 1.8
   
   dependencies {
       compile("org.springframework.boot:spring-boot-starter-data-jpa")
       runtime('mysql:mysql-connector-java')
       testCompile("junit:junit")
   }
   

2. ग्राहक इकाई बनाएँ

   src / मुख्य / जावा / हैलो / Customer.java

   @Entity
   public class Customer {
   
       @Id
       @GeneratedValue(strategy=GenerationType.AUTO)
       private Long id;
       private String firstName;
       private String lastName;
   
       protected Customer() {}
   
       public Customer(String firstName, String lastName) {
           this.firstName = firstName;
           this.lastName = lastName;
       }
   
       @Override
       public String toString() {
           return String.format(
                   "Customer[id=%d, firstName='%s', lastName='%s']",
                   id, firstName, lastName);
       }
   }
   

3. रिपोजिटरी बनाएं

   src / मुख्य / जावा / हैलो / CustomerRepository.java

   import java.util.List;
   import org.springframework.data.repository.CrudRepository;
   
   public interface CustomerRepository extends CrudRepository<Customer, Long> {
       List<Customer> findByLastName(String lastName);
   }
   

4. Application.properties फ़ाइल बनाएँ

   ################### DataSource Configuration ##########################
   jdbc.driverClassName=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql://localhost:3306/your_database_name
   jdbc.username=username
   jdbc.password=password
   
   init-db=false
   
   ################### Hibernate Configuration ##########################
   
   hibernate.dialect=org.hibernate.dialect.MySQLDialect
   hibernate.show_sql=true
   hibernate.hbm2ddl.auto=update
   

5. PersistenceConfig.java फ़ाइल बनाएँ

चरण 5 में, हम परिभाषित करेंगे कि कैसे डेटासोर्स लोड किया जाएगा और हमारा एप्लिकेशन MySQL से कैसे कनेक्ट होगा। उपरोक्त स्निपेट नंगे न्यूनतम कॉन्फ़िगरेशन है जिसे हमें MySQL से कनेक्ट करना होगा। यहाँ हम दो फलियाँ प्रदान करते हैं:

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages="hello")
public class PersistenceConfig 
{
    @Autowired
    private Environment env;
 
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory()
    {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
 
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(Boolean.TRUE);
        vendorAdapter.setShowSql(Boolean.TRUE);
 
        factory.setDataSource(dataSource());
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("hello");
 
        Properties jpaProperties = new Properties();
        jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
        factory.setJpaProperties(jpaProperties);
 
        factory.afterPropertiesSet();
        factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        return factory;
    }
     
    @Bean
    public DataSource dataSource()
    {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.username"));
        dataSource.setPassword(env.getProperty("jdbc.password"));
        return dataSource;
    }
      
}

• LocalContainerEntityManagerFactoryBean यह हमें EntityManagerFactory कॉन्फ़िगरेशन पर एक हैंडल देता है और हमें अनुकूलन करने की अनुमति देता है। यह भी नीचे दिए गए हमारे घटकों में PersistenceContext इंजेक्ट करने के लिए हमें अनुमति देता है:

@PersistenceContext
private EntityManager em;

• DataSource यहाँ हम DriverManagerDataSource का एक उदाहरण देते हैं। यह मानक JDBC डेटा स्रोत इंटरफ़ेस का एक सरल कार्यान्वयन है, सेम गुणों के माध्यम से एक सादे पुराने JDBC ड्राइवर को कॉन्फ़िगर करना और प्रत्येक getConnection कॉल के लिए एक नया कनेक्शन वापस करना। ध्यान दें कि मैं इसे परीक्षण उद्देश्यों के लिए सख्ती से उपयोग करने की सलाह देता हूं क्योंकि BasicDataSource जैसे बेहतर विकल्प उपलब्ध हैं। अधिक जानकारी के लिए यहाँ देखें

6. एक एप्लिकेशन वर्ग बनाएं

   src / मुख्य / जावा / हैलो / Application.java

    @SpringBootApplication
    public class Application {
   
        private static final Logger log = LoggerFactory.getLogger(Application.class);
    
        @Autowired
        private CustomerRepository repository;
    
        public static void main(String[] args) {
            SpringApplication.run(TestCoreApplication.class, args);
        }
    
        @Bean
        public CommandLineRunner demo() {
            return (args) -> {
                // save a couple of customers
                repository.save(new Customer("Jack", "Bauer"));
                repository.save(new Customer("Chloe", "O'Brian"));
                repository.save(new Customer("Kim", "Bauer"));
                repository.save(new Customer("David", "Palmer"));
                repository.save(new Customer("Michelle", "Dessler"));
    
                // fetch all customers
                log.info("Customers found with findAll():");
                log.info("-------------------------------");
                for (Customer customer : repository.findAll()) {
                    log.info(customer.toString());
                }
                log.info("");
    
                // fetch an individual customer by ID
                Customer customer = repository.findOne(1L);
                log.info("Customer found with findOne(1L):");
                log.info("--------------------------------");
                log.info(customer.toString());
                log.info("");
    
                // fetch customers by last name
                log.info("Customer found with findByLastName('Bauer'):");
                log.info("--------------------------------------------");
                for (Customer bauer : repository.findByLastName("Bauer")) {
                    log.info(bauer.toString());
            }
            log.info("");
        };
    }
   

   }

7. अनुप्रयोग चलाना

यदि आप एसटीएस जैसी आईडीई का उपयोग कर रहे हैं , तो आप बस अपनी परियोजना पर राइट क्लिक कर सकते हैं -> रन अस -> ग्रेडल (एसटीएस) बिल्ड ... कार्यों की सूची में, बूटरून और रन टाइप करें।

यदि आप कमांड लाइन पर ग्रेडेल का उपयोग कर रहे हैं , तो आप बस एप्लिकेशन को निम्नानुसार चला सकते हैं:

./gradlew bootRun

आपको कुछ इस तरह से देखना चाहिए:

== Customers found with findAll():
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']

== Customer found with findOne(1L):
Customer[id=1, firstName='Jack', lastName='Bauer']

== Customer found with findByLastName('Bauer'):
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']