基于springscurity基础架构，自己创建两张表，一张person ,字段有 integer id,String iphone,String address. 一张account,字段名 integer id,String name,double balance,关联Person表的主键ID,personId实现两张表联合增删改查的方法。

首先，我们需要定义好两张表的实体类，Person和Account：

Person.java

@Entity
@Table(name = "person")
public class Person {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String phone;
    
    private String address;
    
    // getters and setters
}

Account.java

@Entity
@Table(name = "account")
public class Account {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    private String name;
    
    private Double balance;
    
    @JoinColumn(name = "person_id")
    @ManyToOne(fetch = FetchType.LAZY)
    private Person person;
    
    // getters and setters
}

在Account实体类中，我们使用了@JoinColumn和@ManyToOne注解来关联Person表的主键ID。

接下来，我们需要创建两个DAO接口分别对应两张表的增删改查操作：

PersonDao.java

public interface PersonDao {
    
    void save(Person person);
    
    void update(Person person);
    
    void delete(Integer id);
    
    Person findById(Integer id);
    
    List<Person> findAll();
}

AccountDao.java

public interface AccountDao {
    
    void save(Account account);
    
    void update(Account account);
    
    void delete(Integer id);
    
    Account findById(Integer id);
    
    List<Account> findAll();
}

然后，我们创建两个实现类，分别实现以上接口中的方法：

PersonDaoImpl.java

@Repository
public class PersonDaoImpl implements PersonDao {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    @Override
    public void save(Person person) {
        sessionFactory.getCurrentSession().save(person);
    }
    
    @Override
    public void update(Person person) {
        sessionFactory.getCurrentSession().update(person);
    }
    
    @Override
    public void delete(Integer id) {
        Session session = sessionFactory.getCurrentSession();
        Person person = session.load(Person.class, id);
        if (person != null) {
            session.delete(person);
        }
    }
    
    @Override
    public Person findById(Integer id) {
        return sessionFactory.getCurrentSession().get(Person.class, id);
    }
    
    @Override
    public List<Person> findAll() {
        return sessionFactory.getCurrentSession().createQuery("from Person", Person.class).list();
    }
}

AccountDaoImpl.java

@Repository
public class AccountDaoImpl implements AccountDao {
    
    @Autowired
    private SessionFactory sessionFactory;
    
    @Override
    public void save(Account account) {
        sessionFactory.getCurrentSession().save(account);
    }
    
    @Override
    public void update(Account account) {
        sessionFactory.getCurrentSession().update(account);
    }
    
    @Override
    public void delete(Integer id) {
        Session session = sessionFactory.getCurrentSession();
        Account account = session.load(Account.class, id);
        if (account != null) {
            session.delete(account);
        }
    }
    
    @Override
    public Account findById(Integer id) {
        return sessionFactory.getCurrentSession().get(Account.class, id);
    }
    
    @Override
    public List<Account> findAll() {
        return sessionFactory.getCurrentSession().createQuery("from Account", Account.class).list();
    }
}

最后，我们可以创建一个Service类，将两个DAO接口注入进来，实现对两张表的联合操作：

PersonAccountService.java

@Service
@Transactional
public class PersonAccountService {
    
    @Autowired
    private PersonDao personDao;
    
    @Autowired
    private AccountDao accountDao;
    
    public void save(Person person, Account account) {
        personDao.save(person);
        account.setPerson(person);
        accountDao.save(account);
    }
    
    public void update(Person person, Account account) {
        personDao.update(person);
        account.setPerson(person);
        accountDao.update(account);
    }
    
    public void delete(Integer id) {
        accountDao.delete(id);
        personDao.delete(id);
    }
    
    public Account findAccountById(Integer id) {
        return accountDao.findById(id);
    }
    
    public List<Account> findAllAccounts() {
        return accountDao.findAll();
    }
    
    public Person findPersonById(Integer id) {
        return personDao.findById(id);
    }
    
    public List<Person> findAllPersons() {
        return personDao.findAll();
    }
}

在这个Service类中，我们使用了@Transactional注解控制事务，同时调用了PersonDao和AccountDao中的方法来实现对两张表的联合操作。

最后，我们可以在Controller中注入这个Service类，实现对两张表的增删改查操作。