精通Spring框架：最佳实践与深度解析

需积分: 10 34 浏览量更新于2024-07-18 收藏 8.08MB PDF 举报

"Spring Framework Cookbook 是一本专注于Spring框架学习的手册，主要涵盖了Spring框架的最佳实践，旨在帮助读者深入理解和高效运用Spring。这本书包含了各种优化配置和设计模式的建议，是Spring开发者进阶的必备参考资料。" Spring框架是Java开发中最广泛使用的应用框架之一，它提供了一整套服务，包括依赖注入、面向切面编程、数据访问、事务管理等。本Cookbook将介绍一系列在实际开发中应当遵循的最佳实践，以提升代码质量、可维护性和可扩展性。 1. 定义单例Bean时，使用与类或接口同名的方式。这有助于提高代码的可读性，并能减少因名称不一致导致的混淆。 2. 将Spring Bean配置文件放在特定的文件夹下，而不是根目录。这样可以使项目结构更清晰，便于管理和查找配置。 3. 给Spring Bean配置文件添加通用前缀或后缀。这样做有助于组织配置，使它们更容易被识别和分类。 4. 尽量避免在XML配置文件中使用`<import>`元素。过度使用可能导致配置过于复杂，增加维护难度。 5. 避免在基于XML的配置中使用自动装配。尽管自动装配可以简化配置，但在某些情况下可能导致难以追踪的依赖关系。 6. 始终使用属性占位符来外部化Bean的属性值。这允许在不修改代码的情况下改变配置，增强了灵活性。 7. 选择无版本号的XSD导入命名空间定义。这有助于保持配置的兼容性，减少升级时可能出现的问题。 8. 总是在资源路径中加上"classpath:"前缀。这确保了资源的正确加载，特别是在处理类路径资源时。 9. 即使使用字段级自动装配，也应提供一个setter方法。这提供了额外的灵活性，如在测试中替换依赖。 10. 即使服务层的方法几乎只是简单地转发到对应的DAO方法，也应该创建一个单独的服务层。这样做有利于遵循单一职责原则，提高代码可维护性。 11. 在使用注解驱动的Bean配置时，尽可能多使用 sterotype 注解（如@Service、@Repository、@Controller）。这有助于增强代码的语义，提高可读性。 12. 将相关的处理器方法分组到不同的Controller bean中。这有助于代码的组织，使得控制器更具可读性和可测试性。以上内容只是《Spring Framework Cookbook》的部分精华，书中还可能涉及更多关于AOP、数据访问、事务管理、安全等方面的最佳实践。通过学习这本书，读者可以深入理解Spring框架，并将其应用到实际项目中，提高开发效率和软件质量。

Spring Framework Cookbook 6 / 184

}

@Repository

public class HibernateSecurityDao implements SecurityDao {

private SessionFactory sessionFactory;

@Autowired

public void setSessionFactory(SessionFactory sessionFactory) {

this.sessionFactory = sessionFactory;

}

//...

}

1.12 Group handler methods according to related scenarios in different Controller

beans

Spring MVC allows you to write multiple handler methods within a single Controller bean. However, this approach might

lead Controller classes to get cluttered unless you become careful. For example, you will need to add methods that initialize

model objects using @ModelAttribute annotation, or add exception handler methods with @ExceptionHandler annotation, or

init methods to initialize WebDataBinder with @InitBinder annotation, and things will get collide with each other for different

scenarios over time. Instead, you should create several Controller classes for each group of related scenarios in the application,

so that any of those initializing or error handling methods related with the same scenarios goes into same Controller classes. This

will result in more manageable and understandable Controller beans in the end.

Do not place business logic in Controller beans. Role of Controller beans is to handle web request, extract user submitted data,

convert it into an appropriate form for service layer, invoke service layer for business execution, then get the result from service

layer and build up response for the user to be shown. Do not let the business logic leak into the Controller beans. The only logic

allowed in the Controller beans should be UI logic, which is mainly related with managing state for the UI, nothing else.

1.13 Place annotations over concrete classes and their methods instead of their

interfaces

You should place Spring annotations only over classes, their ﬁelds or methods, not on interfaces or methods declared within

them, as Java doesn’t allow annotations placed on interfaces to be inherited by the implementing classes.

1.14 Prefer throwing runtime exceptions instead of checked exceptions from ser-

vice layer

Default rollback behavior for @Transactional annotation is to commit when a checked exception is thrown from within a trans-

actional method, instead of rollback, as opposed to its counterpart, unchecked exceptions, which cause rollback by default.

However, most of the time developers need rollback behavior for checked exceptions as well. Therefore, they override default

rollback behavior, whenever they throw checked exceptions and want to cause rollback. Instead of repeating this step each time

for your transactional service methods, it will be much safer to throw unchecked exceptions from within those service methods.

@Service

public class SecurityServiceImpl implements SecurityService {

@Autowired

private SecurityDao securityDao;

Spring Framework Cookbook 8 / 184

Such a dirty checking step obviously becomes unnecessary when we only perform select queries. Turning ﬂush mode to manual

prevents automatic ﬂushing at the end of the transaction commit, and this will bring us a slight performance improvement, in

addition to preventing unintended data modiﬁcations in the application.

@Service

public class SecurityServiceImpl implements SecurityService {

@Autowired

private SecurityDao securityDao;

@Override

@Transactional(readOnly=true)

public User findUserByUsername(String username) {

//...

}

//...

}

1.17 Be aware of false positives in transactional ORM integration tests

Spring TextContext Framework helps us to create transactional integration tests so that it becomes easier to test data access

operations. It rollbacks the transaction created at the end of the test method in order not to cause side effects to other tests to

be run next. If you are using JPA or Hibernate in your data access operations, JPA/Hibernate won’t ﬂush as the transaction rolls

back, and SQL statements won’t hit the database therefore. Hence, you won’t be aware of any problems like constraint violations

caused by those data access operations as no SQL is executed actually.

In order to overcome this problem, you need to inject SessionFactory or EntityManager, and perform ﬂush before assert state-

ments in the test methods.

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:/appcontext/beans-

.xml")

public class SecurityIntegrationTests {

@Autowired

private SessionFactory sessionFactory;

@Autowired

private SecurityDao securityDao;

@Test

@Transactional

public void shouldCreateNewUser() {

User user = new User();

user.setUsername("john");

user.setPassword("secret");

securityDao.createUser(user);

sessionFactory.getCurrentSession().flush();

}

1.18 Do not use DriverManagerDataSource

DriverManagerDataSource class is mostly used one to exemplify dataSource bean conﬁgurations throughout Spring related

examples. However, DriverManagerDataSource causes a new physical connection to be opened each time you ask for an SQL

Spring Framework Cookbook 9 / 184

Connection from it, as it doesn’t have a pooling mechanism. It is suitable only for development or testing environments. You

should not use it in production environment. Instead you should either access dataSource bean conﬁgured within your application

server via JNDI, or include an open source connection pooling library, like C3PO, Apache Commons DBCP or Hikari, and get

connections through that connection pool.

<jee:jndi-lookup jndi-name="java:comp/env/jdbc/myDS" id="dataSource"/>

1.19 Either use NamedParameterJdbcTemplate or JdbcTemplate for your JDBC op-

erations

Spring Data Access module provides two high level helper classes, JdbcTemplate and NamedParameterJdbcTemplate. You

should use either one of them to perform any of your JDBC operations, instead of getting dataSource bean and opening up JDBC

connections manually. Those template method based classes handle most of the repetitious code blocks internally, and relieves

us from managing JDBC connections by ourselves. They also simplify combining ORM operations with native JDBC ones in

the same transaction.

@Repository

public class JdbcSecurityDao implements SecurityDao {

private JdbcTemplate jdbcTemplate;

@Autowired

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

</bean>

1.20 Use SessionFactory and EntityManager directly in your DAO beans

Before introduction of contextual session capability of Hibernate, Spring had provided HibernateTemplate helper class, similar to

JdbcTemplate to simplify ORM operations inside DAO classes. The other class provided by Spring was HibernateDaoSupport for

DAO classes to extend from for similar purposes. However, with the introduction of contextual session capability, working with

Hibernate has been greatly simpliﬁed, and reduced to injecting SessionFactory into DAO beans, and calling getCurrentSession()

to access transactional current Session to perform persistence operations. Therefore, prefer that type of usage within your DAO

beans instead of cluttering them with an additional helper or base class.

@Repository

public class HibernateSecurityDao implements SecurityDao {

private SessionFactory sessionFactory;

@Autowired

public void setSessionFactory(SessionFactory sessionFactory) {

this.sessionFactory = sessionFactory;

}

public User findUserByUsername(String username) {

return sessionFactory.getCurrentSession().createQuery("from User u where u. ←-

username = :username")

.setParameter("username", username).uniqueResult();

}

剩余193页未读，继续阅读

wensoft-J

粉丝: 1
资源: 1

精通Spring框架：最佳实践与深度解析

Spring Cookbook

Spring入门指南（Spring Cookbook）-2015年英文原版，0积分

Spring Cookbook epub

flask framework cookbook - second edition pdf

SpringBoot相关的外文文献有哪些

Spring BOOT参考文献

java spring boot 外文文献

spring boot项目英文文献

关于springboot的英文文献

基于spring boot的毕业设计参考文献

最新资源