Spring ORM Framework Introduction and Basic Concept
Spring ORM Framework Introduction and Basic Concept
Spring ORM is a solution for the Object Relational Mapping provided by the Spring framework to simplify the interactive operation between the Java application and the relational database.It is based on the ORM framework such as Hibernate and provides an object -based persistent operation, allowing developers to operate the database in an object -oriented way without the need to care about the underlying SQL statement.
The core advantage of the Spring ORM framework is seamless integration with the Spring framework.By combining with the Spring IOC container, Spring ORM provides a lightweight, flexible and scalable way to integrate the ORM framework, so that developers can more conveniently configure and manage durable objects.
The basic concepts of Spring ORM include:
1. Entity class: The physical class is a Java class mapped to the database table. The instances of each class correspond to a line of data in the database table.The physical class is a mapping relationship between the database table through annotation or XML configuration.
2. Data Access Object (DAO): DAO is an interface or class used to encapsulate the access and operation of the database.Through DAO, applications can perform CRUD operations on the database (creation, read, update, delete).
3. Session Factory: The session factory is an important concept of the Spring ORM framework. It is responsible for creating and managing the session objects.The session factory is safe and can be shared by the entire application.
4. Transaction Management: Spring ORM also provides the function of transaction management to manage database transactions by programming or declaration.Affairs management can ensure the consistency and integrity of data, while improving the performance and reliability of the system.
Below is a simple example that shows the basic usage of the Spring ORM framework:
First, configure the relevant information of the data source and the session factory in the Spring configuration file:
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/mydatabase" />
<property name="username" value="username" />
<property name="password" value="password" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.example.models" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
Then define the physical class and DAO interface:
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
// Getters and setters
}
public interface UserDao {
User findById(Long id);
void save(User user);
void delete(User user);
}
Implement DAO interface:
@Repository
@Transactional
public class UserDaoImpl implements UserDao {
@Autowired
private SessionFactory sessionFactory;
@Override
public User findById(Long id) {
Session session = sessionFactory.getCurrentSession();
return session.get(User.class, id);
}
@Override
public void save(User user) {
Session session = sessionFactory.getCurrentSession();
session.saveOrUpdate(user);
}
@Override
public void delete(User user) {
Session session = sessionFactory.getCurrentSession();
session.delete(user);
}
}
Finally, use DAO to perform database operations in the application:
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
UserDao userDao = context.getBean(UserDao.class);
// Create a new user
User user = new User();
user.setUsername("test");
user.setPassword("123456");
userDao.save(user);
// Query the user
User retrievedUser = userDao.findById(user.getId());
System.out.println("Username: " + retrievedUser.getUsername());
}
}
Through the above examples, we can see that the Spring ORM framework provides a simple and powerful way for database operations.Through the integration with the Spring framework, it simplifies the work of developers and improves the maintenance and scalability of the application.
