{ "parameters":[ { "FromId":"UALA_CG_AuditBuildTest" ,"Keys":"FBILLNO,F_YCZ_CONTRACTNUMBER,F_YCZ_CONTRACTNAME,CONVERT(DECIMAL(18,2),F_YCZ_ContractAmount) AS F_YCZ_ContractAmount" ,"Where":"F_YCZ_CONTRACTNUMBER not like '%3'" ,"Order":"F_YCZ_ContractAmount desc" } ] }

这是一个 SQL 查询，意思是从名为 "UALA_CG_AuditBuildTest" 的表中选择 FBILLNO、F_YCZ_CONTRACTNUMBER、F_YCZ_CONTRACTNAME 和 F_YCZ_ContractAmount 字段，并将 F_YCZ_ContractAmount 转换为 decimal 类型。结果集中只包含 F_YCZ_CONTRACTNUMBER 不以 "3" 结尾的行，按照 F_YCZ_ContractAmount 降序排列。

相关问题

jdbctemplate 事务_Spring编程式和声明式事务实例讲解

在 Spring 中，我们可以通过编程式事务和声明式事务来处理数据库事务。下面我来分别介绍一下这两种事务的实现。

## 编程式事务

编程式事务是通过代码实现事务控制，需要手动创建和提交事务。Spring 提供了一个名为 `TransactionTemplate` 的类来帮助我们实现编程式事务。

我们可以使用 `TransactionTemplate` 来控制事务的开启、提交、回滚等操作。下面是一个简单的例子：

@Service
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void transfer(int fromId, int toId, int amount) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    jdbcTemplate.update("update account set amount = amount - ? where id = ?", amount, fromId);
                    jdbcTemplate.update("update account set amount = amount + ? where id = ?", amount, toId);
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw e;
                }
            }
        });
    }
}

上面的代码中，我们使用 `TransactionTemplate` 来控制转账操作的事务，如果出现异常，则会回滚事务。

## 声明式事务

声明式事务是通过配置文件来实现事务控制，无需手动创建和提交事务。Spring 提供了一个叫做 `@Transactional` 的注解来帮助我们实现声明式事务。

我们只需要在需要添加事务的方法上加上 `@Transactional` 注解，就可以实现声明式事务。下面是一个简单的例子：

@Service
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        jdbcTemplate.update("update account set amount = amount - ? where id = ?", amount, fromId);
        jdbcTemplate.update("update account set amount = amount + ? where id = ?", amount, toId);
    }
}

上面的代码中，我们在 `transfer` 方法上添加了 `@Transactional` 注解，这样就可以实现转账操作的事务控制了。

声明式事务的好处是我们无需手动创建和提交事务，代码更加简洁，但是配置稍微复杂一些。

Java：创建银行账户，并进行管理、Dao和Service分层实现。

好的，让我们来实现一个简单的银行账户管理系统。首先，我们需要定义一个`Account`类，表示银行账户，包含账户ID、账户名、账户余额等属性。

public class Account {
    private int id;
    private String name;
    private double balance;

    public Account(int id, String name, double balance) {
        this.id = id;
        this.name = name;
        this.balance = balance;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

接下来，我们需要定义一个`AccountDao`接口，用于对银行账户进行CRUD操作。同时，我们需要定义一个具体的实现类`AccountDaoImpl`，实现`AccountDao`接口中的方法，实现对银行账户的操作。

public interface AccountDao {
    void addAccount(Account account);
    void removeAccount(int id);
    void updateAccount(Account account);
    Account getAccountById(int id);
    List<Account> getAllAccounts();
}

public class AccountDaoImpl implements AccountDao {
    private List<Account> accounts = new ArrayList<>();
    private int nextId = 1;

    @Override
    public void addAccount(Account account) {
        account.setId(nextId++);
        accounts.add(account);
    }

    @Override
    public void removeAccount(int id) {
        accounts.removeIf(account -> account.getId() == id);
    }

    @Override
    public void updateAccount(Account account) {
        Account oldAccount = accounts.stream()
                .filter(a -> a.getId() == account.getId())
                .findFirst()
                .orElse(null);
        if (oldAccount != null) {
            oldAccount.setName(account.getName());
            oldAccount.setBalance(account.getBalance());
        }
    }

    @Override
    public Account getAccountById(int id) {
        return accounts.stream()
                .filter(account -> account.getId() == id)
                .findFirst()
                .orElse(null);
    }

    @Override
    public List<Account> getAllAccounts() {
        return accounts;
    }
}

最后，我们需要定义一个`AccountService`接口，用于调用`AccountDao`中的方法，并提供更高级别的服务，例如转账、查询余额等。

public interface AccountService {
    void createAccount(String name, double balance);
    void removeAccount(int id);
    void updateAccount(int id, String name, double balance);
    Account getAccountById(int id);
    List<Account> getAllAccounts();
    void transfer(int fromId, int toId, double amount);
    double getBalance(int id);
}

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public AccountServiceImpl(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void createAccount(String name, double balance) {
        Account account = new Account(0, name, balance);
        accountDao.addAccount(account);
    }

    @Override
    public void removeAccount(int id) {
        accountDao.removeAccount(id);
    }

    @Override
    public void updateAccount(int id, String name, double balance) {
        Account account = accountDao.getAccountById(id);
        if (account != null) {
            account.setName(name);
            account.setBalance(balance);
            accountDao.updateAccount(account);
        }
    }

    @Override
    public Account getAccountById(int id) {
        return accountDao.getAccountById(id);
    }

    @Override
    public List<Account> getAllAccounts() {
        return accountDao.getAllAccounts();
    }

    @Override
    public void transfer(int fromId, int toId, double amount) {
        Account fromAccount = accountDao.getAccountById(fromId);
        Account toAccount = accountDao.getAccountById(toId);
        if (fromAccount != null && toAccount != null) {
            double balance = fromAccount.getBalance();
            if (balance >= amount) {
                fromAccount.setBalance(balance - amount);
                toAccount.setBalance(toAccount.getBalance() + amount);
                accountDao.updateAccount(fromAccount);
                accountDao.updateAccount(toAccount);
            } else {
                throw new RuntimeException("Insufficient balance.");
            }
        }
    }

    @Override
    public double getBalance(int id) {
        Account account = accountDao.getAccountById(id);
        if (account != null) {
            return account.getBalance();
        }
        return 0;
    }
}

这样，我们就完成了银行账户管理系统的设计和实现。我们可以使用以下代码进行测试：

public class BankApp {
    public static void main(String[] args) {
        AccountDao accountDao = new AccountDaoImpl();
        AccountService accountService = new AccountServiceImpl(accountDao);

        accountService.createAccount("Alice", 1000);
        accountService.createAccount("Bob", 2000);

        System.out.println("All accounts:");
        accountService.getAllAccounts().forEach(System.out::println);

        accountService.transfer(1, 2, 500);

        System.out.println("Alice's balance: " + accountService.getBalance(1));
        System.out.println("Bob's balance: " + accountService.getBalance(2));
    }
}

输出结果如下：

All accounts:
Account{id=1, name='Alice', balance=1000.0}
Account{id=2, name='Bob', balance=2000.0}
Alice's balance: 500.0
Bob's balance: 2500.0