Fatal编程技术网
  • java/
  • Java 如何使用SpringMVC和hibernate连接/绑定两个表

Java 如何使用SpringMVC和hibernate连接/绑定两个表

java spring hibernate spring-mvc

Java 如何使用SpringMVC和hibernate连接/绑定两个表,java,spring,hibernate,spring-mvc,Java,Spring,Hibernate,Spring Mvc,我的英语不是很好，所以很抱歉出错 我使用的是Spring，Spring MVC，Hibernate，Spring数据 我有两个实体Customer和CustomerDetails，我想连接/绑定它们。 我正在使用@OneToOne注释，但我不知道如何为CusomerDetails设置客户，反之亦然。我发现我应该在controller中创建Customer和CustomerDetails，并在那里连接它们，但它不起作用，我认为这是一种糟糕的方法。有人知道它应该是什么样子吗 谢谢你的帮助 客户类别：

我的英语不是很好，所以很抱歉出错

我使用的是Spring，Spring MVC，Hibernate，Spring数据

我有两个实体Customer和CustomerDetails，我想连接/绑定它们。 我正在使用@OneToOne注释，但我不知道如何为CusomerDetails设置客户，反之亦然。我发现我应该在controller中创建Customer和CustomerDetails，并在那里连接它们，但它不起作用，我认为这是一种糟糕的方法。有人知道它应该是什么样子吗

谢谢你的帮助

客户类别：

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="customer")
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="customer_id")
    private int id;

    @Column(name="name")
    private String name;

    @Column(name="email")
    private String email;

    @Column(name="address")
    private String address;

    @OneToOne(cascade=CascadeType.ALL)
    private CustomerDetails customerDetails;

    public Customer() {
    }

    public Customer(CustomerDetails customerDetails)
    {
        this.customerDetails=customerDetails;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }



    public CustomerDetails getCustomerDetails() {
        return customerDetails;
    }

    public void setCustomerDetails(CustomerDetails customerDetails) {
        this.customerDetails = customerDetails;
    }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", address=" + address
                + ", customerDetails=" + customerDetails + "]";
    }

}
客户详情：


import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="customer_details")
public class CustomerDetails {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;

    @Column(name="surname")
    private String lastName;

    @Column(name="number")
    private int number;

    @OneToOne(cascade= {CascadeType.DETACH,CascadeType.MERGE,CascadeType.PERSIST,CascadeType.REFRESH})
    private Customer customer;




    public CustomerDetails() {

    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public String toString() {
        return "CustomerDetails [id=" + id + ", lastName=" + lastName + ", number=" + number + ", customer=" + customer
                + "]";
    }


}

@OneToOne(mappedBy = "customer_detail")
服务：

import java.util.List;

import com.firstapp.entity.Customer;

public interface CustomerService {

    public List<Customer>getCustomers();

    public Customer getCustomer(int id);

    public void saveCustomer(Customer customer);

    public void deleteCustomer(int id);

    public List<Customer>search(String keyword);

}


public interface CustomerDetailsService {

    public List<CustomerDetails> getCustomers();

    public CustomerDetails getCustomer(int id);

    public void saveCustomer(CustomerDetails customer);

    public void deleteCustomer(int id);
}


@Service
public class CustomerServiceImpl implements CustomerService {

    @Autowired
    private CustomerRepository repo;

    public List<Customer> getCustomers() {
        return repo.findAll();
    }

    public Customer getCustomer(int id) {
        Optional<Customer>result= repo.findById(id);
        return result.get();
    }

    public void saveCustomer(Customer customer) {
        repo.save(customer);
    }

    public void deleteCustomer(int id) {
        repo.deleteById(id);
    }

    public List<Customer>search(String keyword)
    {
        return repo.search(keyword);
    }


}



import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.firstapp.entity.CustomerDetails;
import com.firstapp.repository.CustomerDetailsRepository;

@Service
public class CustomerDetailsServiceImpl implements CustomerDetailsService{

    @Autowired
    private CustomerDetailsRepository repo;

    public List<CustomerDetails> getCustomers() {
        return repo.findAll();
    }

    public CustomerDetails getCustomer(int id) {
        return repo.findById(id).get();
    }

    public void saveCustomer(CustomerDetails customer) {
        repo.save(customer);
    }

    public void deleteCustomer(int id) {
        repo.deleteById(id);
    }
}


import java.util.List；
导入com.firstapp.entity.Customer；
公共接口客户服务{
public ListgetCustomers（）；
公共客户getCustomer（int-id）；
公共作废保存客户（客户）；
公共客户（内部id）；
公共列表搜索（字符串关键字）；
}
公共接口CustomerDetailsService{
公共列表getCustomers（）；
公共客户详细信息getCustomer（int id）；
公共作废保存客户（客户明细客户）；
公共客户（内部id）；
}
@服务
公共类CustomerServiceImpl实现CustomerService{
@自动连线
私人客户存款回购；
公共列表getCustomers（）{
返回回购findAll（）；
}
公共客户getCustomer（内部id）{
Optionalresult=repo.findById（id）；
返回result.get（）；
}
公共作废保存客户（客户）{
回购保存（客户）；
}
公共客户（内部id）{
回购协议删除id（id）；
}
公共列表搜索（字符串关键字）
{
返回回购搜索（关键字）；
}
}
导入java.util.List；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.stereotype.Service；
导入com.firstapp.entity.CustomerDetails；
导入com.firstapp.repository.CustomerDetailsRepository；
@服务
公共类CustomerDetailsServiceImpl实现CustomerDetailsService{
@自动连线
私人客户详细存款回购；
公共列表getCustomers（）{
返回回购findAll（）；
}
公共客户详细信息getCustomer（int id）{
返回repo.findById（id.get（）；
}
公共作废保存客户（客户详细信息客户）{
回购保存（客户）；
}
公共客户（内部id）{
回购协议删除id（id）；
}
}
存储库：

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import com.firstapp.entity.Customer;

@Repository
public interface CustomerRepository extends JpaRepository<Customer, Integer> {

    @Query(value="SELECT c from Customer c where c.name LIKE '%'|| :keyword || '%'"
            + "OR c.email LIKE '%'|| :keyword || '%'"
            + "OR c.address LIKE '%'|| :keyword || '%'")
    public List<Customer>search(@Param("keyword")String keyword);
}


import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.firstapp.entity.CustomerDetails;

@Repository
public interface CustomerDetailsRepository extends JpaRepository<CustomerDetails, Integer> {

}


import java.util.List；
导入org.springframework.data.jpa.repository.JpaRepository；
导入org.springframework.data.jpa.repository.Query；
导入org.springframework.data.repository.query.Param；
导入org.springframework.stereotype.Repository；
导入com.firstapp.entity.Customer；
@存储库
公共接口CustomerRepository扩展了JpaRepository{
@Query（value=“从客户c中选择c，其中c.name类似于“%”关键字“%””
+“或类似“%”| |：关键字| |“%”的c.email”
+“或c.地址，如“%”关键字“%”）
公共列表搜索（@Param（“关键字”）字符串关键字）；
}
导入org.springframework.data.jpa.repository.JpaRepository；
导入org.springframework.stereotype.Repository；
导入com.firstapp.entity.CustomerDetails；
@存储库
公共接口CustomerDetailsRepository扩展了JpaRepository{
}
我的控制器：

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.firstapp.entity.Customer;
import com.firstapp.entity.CustomerDetails;
import com.firstapp.service.CustomerDetailsService;
import com.firstapp.service.CustomerDetailsServiceImpl;
import com.firstapp.service.CustomerService;
import com.firstapp.service.CustomerServiceImpl;

@Controller
@RequestMapping("/customer")public class CustomerController {

    @Autowired
    private CustomerService service;

    @Autowired
    private CustomerDetailsService serviceCD;

    @GetMapping("/home")public String home(Model model)
    {       
        List<Customer>customers=service.getCustomers();
        model.addAttribute("message","Hello from Spring MVC");  model.addAttribute("customers",customers);
        return "home-page";
    }

    @GetMapping("/showForm")
    public String showForm(Map<String,Object>model)
    {
        Customer customer=new Customer();
        CustomerDetails cd=new CustomerDetails();
        customer.setCustomerDetails(cd);
        model.put("customer",new Customer());
        model.put("customerDetails", cd);
        return "new-customer";
    }

    @PostMapping("/add")
    public String addCustomer(@ModelAttribute("customer") Customer customer)
    {
        service.saveCustomer(customer);
        return "redirect:/customer/addDetails";
    }

    @RequestMapping("/addDetails")
    public String addCustomerDetails(@ModelAttribute("customerDetails") CustomerDetails customerDt)
    {
        serviceCD.saveCustomer(customerDt);
        return "redirect:/customer/home";
    }



    @GetMapping("/edit")
    public String editCustomer(@RequestParam int id, Model model)
    {
        Customer customer=service.getCustomer(id);
        model.addAttribute("customer",customer);
        return "edit-customer";
    }

    @GetMapping("/delete")
    public String deleteCustomer(@RequestParam int id)
    {
        service.deleteCustomer(id);
        return "redirect:/customer/home";
    }

    @GetMapping("/search")
    public String search(@RequestParam String keyword,Model model)
    {
        List<Customer>customers=service.search(keyword);
        model.addAttribute("customers",customers);
        return "search-page";
    }
}


import java.util.List；
导入java.util.Map；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.stereotype.Controller；
导入org.springframework.ui.Model；
导入org.springframework.web.bind.annotation.GetMapping；
导入org.springframework.web.bind.annotation.ModelAttribute；
导入org.springframework.web.bind.annotation.PostMapping；
导入org.springframework.web.bind.annotation.RequestMapping；
导入org.springframework.web.bind.annotation.RequestParam；
导入com.firstapp.entity.Customer；
导入com.firstapp.entity.CustomerDetails；
导入com.firstapp.service.CustomerDetailsService；
导入com.firstapp.service.CustomerDetailsServiceImpl；
导入com.firstapp.service.CustomerService；
导入com.firstapp.service.CustomerServiceImpl；
@控制器
@请求映射（“/customer”）公共类CustomerController{
@自动连线
私人客户服务；
@自动连线
私人客户详细服务CD；
@GetMapping（“/home”）公共字符串home（模型）
{       
Listcustomers=service.getCustomers（）；
model.addAttribute（“消息”，“来自SpringMVC的你好”）；model.addAttribute（“客户”，客户）；
返回“主页”；
}
@GetMapping（“/showForm”）
公共字符串显示表单（Mapmodel）
{
客户=新客户（）；
CustomerDetails cd=新CustomerDetails（）；
customer.setCustomerDetails（cd）；
model.put（“客户”，新客户（））；
模型放置（“客户详细信息”，cd）；
返回“新客户”；
}
@后映射（“/add”）
公共字符串addCustomer（@modeldattribute（“客户”）客户）
{
服务。保存客户（客户）；
返回“重定向：/customer/addDetails”；
}
@请求映射（“/addDetails”）
公共字符串addCustomerDetails（@ModelAttribute（“customerDetails”）customerDetails customerDt）
{
serviceCD.saveCustomer（customerDt）；
返回“重定向：/customer/home”；
}
@GetMapping（“/edit”）
公共字符串editCustomer（@RequestParam int-id，Model）
{
Customer=service.getCustomer（id）；
model.addAttribute（“客户”，客户）；
返回“编辑客户”；
}
@GetMapping（“/delete”）
公共字符串deleteCustomer（@RequestParam int-id）
{
服务。删除客户（id）；
返回“重定向：/customer/home”；
}
@GetMapping（“/search”）
公共字符串搜索（@RequestParam字符串关键字，模型）
{
Listcustomers=service.search（关键字）；
model.addAttribute（“客户”，客户）；
返回“搜索”-

customer.setCustomerDetail(customerDetail);
customerDetail.setCustomer(customer);



@OneToOne(mappedBy = "customer")
@JoinColumn(name = "customer_details_id", referencedColumnName = "id")



@OneToOne(mappedBy = "customer_detail")