spring练习二

首先我先理解AOP编程和事务管理

面向对象编程（Object-Oriented Programming，简称 OOP）是一种基于对象的软件开发方法。在OOP中，我们将现实世界中的事物抽象成一个个对象，并通过对象之间的交互来完成各种功能。OOP主要包含以下三个基本概念：

封装：将数据和对数据的操作封装在一起，以便对象能够控制自己的状态和行为。继承：通过继承机制，可以使子类获得父类的属性和方法，从而减少重复代码的编写。多态：多态指的是同一个方法调用，在不同情况下会产生不同的结果，这使得我们可以使用统一的接口来处理不同的对象。

AOP编程面向切面编程（Aspect-Oriented Programming，简称 AOP）：是一种程序设计思想，它可以让我们将共性问题解耦出来，从而实现更好的模块化和复用性。AOP中的核心概念是切面（aspect）、连接点（join point）和通知（advice）。切面定义了在哪些连接点上应该执行通知，通知则定义了要在连接点上执行的具体操作。

事务管理：事务指的是在数据库操作中，一组相关的操作被视为一个整体进行处理。如果其中任意一个操作失败，整个事务将回滚，即所有操作都失效。事务管理是指对这些操作进行管理，以确保它们都成功或都失败。

了解这些后，我开始了实操

练习how2j面向sop的编程，理解面向对象编程的含义这部分内容是在how2j网站上的Spring系列教材中学习的，主要涉及AOP编程的基础知识和相关概念。这里给出其中的一个示例代码：

public interface UserDao {
    void addUser();
    void deleteUser();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

public class UserDaoProxy implements UserDao {
    private UserDao userDao;

    public UserDaoProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void addUser() {
        System.out.println("开始添加用户...");
        userDao.addUser();
        System.out.println("添加用户完成。");
    }

    @Override
    public void deleteUser() {
        System.out.println("开始删除用户...");
        userDao.deleteUser();
        System.out.println("删除用户完成。");
    }
}

public class Test {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
        UserDaoProxy proxy = new UserDaoProxy(userDao);
        proxy.addUser();
        proxy.deleteUser();
    }
}

这段代码模拟了一个简单的代理模式，其中 UserDao 接口定义了两个方法 addUser 和 deleteUser，UserDaoImpl 类实现了这两个方法。在 UserDaoProxy 类中对 addUser 和 deleteUser 进行了增强操作，然后在 Test 类中创建 UserDaoImpl 对象并通过 UserDaoProxy 进行使用。

练习p262 11-6的案例，体会编程式事务管理。这部分内容是在Spring实战教材第11章“为数据添加事务支持”的第6节“基于编程的事务管理”中学习的。下面是示例代码：

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
    public void add(User user) {
        userDao.addUser(user);
    }

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
    public void delete(int id) {
        userDao.deleteUser(id);
    }
}

@Component
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void addUser(User user) {
        String sql = "INSERT INTO user(name, age) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getAge());
    }

    public void deleteUser(int id) {
        String sql = "DELETE FROM user WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }
}

public class Test {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = context.getBean(UserService.class);
        User user = new User();
        user.setName("Bob");
        user.setAge(23);
        userService.add(user);
        userService.delete(1);
    }
}

这段代码中使用了编程式事务管理，即在 UserService 的 add 方法和 delete 方法上添加了 @Transactional 注解，并指定了传播行为和隔离级别。在 Test 类中创建 ApplicationContext 对象并获取 UserService 对象，然后调用其 add 和 delete 方法即可完成相应的数据库操作。

练习p263 11-7的案例，体会声明式事务管理。这部分内容也是在Spring实战教材第11章“为数据添加事务支持”的第7节“基于声明式事务管理”中学习的。下面是示例代码：

@Configuration
@EnableTransactionManagement
@PropertySource("classpath:jdbc.properties")
public class AppConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource());
        return transactionManager;
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }

    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }

    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional
    public void add(User user) {
        userDao.addUser(user);
    }

    @Override
    @Transactional
    public void delete(int id) {
        userDao.deleteUser(id);
    }
}

public interface UserDao {
    void addUser(User user);
    void deleteUser(int id);
}

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void addUser(User user) {
        String sql = "INSERT INTO user(name, age) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getAge());
    }

    @Override
    public void deleteUser(int id) {
        String sql = "DELETE FROM user WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }
}

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        User user = new User();
        user.setName("Tom");
        user.setAge(22);
        userService.add(user);
        userService.delete(1);
        context.close();
    }
}

这段代码中使用了声明式事务管理，即在 AppConfig 类中通过 @EnableTransactionManagement 注解开启了事务管理，并配置了数据源和事务管理器。在 UserServiceImpl 中对 add 方法和 delete 方法进行了事务注解的配置，并在 Test 类中调用相应的方法完成数据库操作。

总结一下，本次实验主要学习了AOP编程和事务管理两个方面的内容。在AOP编程中，我们学习了切面、连接点和通知等概念，并通过示例代码模拟了一个简单的代理模式。在事务管理中，我们学习了编程式事务管理和声明式事务管理两种方式，并通过示例代码对其进行了实现。这些知识点都是Spring框架中非常重要的组成部分，掌握它们对于我们使用Spring进行应用开发非常有帮助。

这是我实操过程中的图片