JpaManytoMany

package com.allqj.calculator.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
import java.io.Serializable;
import java.util.List;
/**
 * spec多表尝试电影表实体类
 *
 * @author Xing
 * @CREATE 2018-03-21
 */
@Entity
@Setter
@Getter
@Table(name = "movie")
public class MovieBean implements Serializable {
    @Id
    @GenericGenerator(name = "bb", strategy = "guid")
    @GeneratedValue(generator = "bb")
    @Column(name = "mid", nullable = false)
    private String mid;

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

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

    @Column(name = "mfeel")
    private String mfeel;
    @JsonIgnoreProperties(value = { "movies" })
    //@JsonIgnore
    @ManyToMany(mappedBy = "movies")
    private List<SuperStarBean> supers;
}
//@OneToMany(mappedBy="movies",/*targetEntity=SuperstarToMovie.class,(如果使用泛型来定义集合以指定元素类型，则不需要指定关联的目标实体类型; 否则必须指定目标实体类)*/fetch=FetchType.LAZY)

package com.allqj.calculator.entity;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import com.allqj.calculator.entity.MovieBean;
import org.hibernate.annotations.GenericGenerator;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import javax.persistence.*;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
 * spec多表尝试演员表实体类
 *
 * @author Xing
 * @CREATE 2018-03-12-18:31
 */

@Entity
@Getter
@Setter
@Table(name = "superstar")
public class SuperStarBean implements Serializable {
    @Id
    @GenericGenerator(name = "aa", strategy = "guid")
    @GeneratedValue(generator = "aa")
    @Column(name = "sid", nullable = false)
    private String sid;

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

    @Column(name = "sex")
    private String sex;
    @JsonIgnoreProperties(value = { "supers" })
    @ManyToMany(fetch = FetchType.EAGER, cascade ={ CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH,CascadeType.REMOVE})
    @JoinTable(name = "movie_superstar",
            joinColumns = {
                    @JoinColumn(name = "sid")},
            inverseJoinColumns = {
                    @JoinColumn(name = "mid")})

    private List<MovieBean> movies;

}

package com.allqj.calculator.controller;

import com.allqj.calculator.entity.MovieBean;
import com.allqj.calculator.entity.SuperStarBean;
import com.allqj.calculator.service.ZmanyService;
import com.allqj.qjf.common.controller.BaseController;
import com.allqj.qjf.common.vo.ResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

/**
 * spec多表尝试Controller层
 *
 * @author Xing
 * @CREATE 2018-03-12-18:30
 */
@RestController
@RequestMapping("/tomany")
public class ZmanyController extends BaseController {
    @Autowired
    private ZmanyService s;

    @ResponseBody
    //根据演员名查询信息
    @RequestMapping("/superlist")
    public ResultVO list(@RequestBody SuperStarBean stom) {
        List<SuperStarBean> list = s.findAllbySuper(stom);
        return ok(list);
    }

    //根据电影名查询信息
    @RequestMapping("/movielist")
    public ResultVO list1(@RequestBody MovieBean mb) {
        List<MovieBean> list1 = s.findAllbyMovie(mb);
        return ok(list1);
    }

    //删除演员信息中的某部电影關聯
    @RequestMapping("/delmovie")
    public ResultVO delmovie(@RequestBody String sid) {
        s.delmovie(sid);
        return ok();
    }

    //刪除電影信息中的某位演員關聯
    @RequestMapping("/delsuper")
    public ResultVO delsuper(@RequestBody String mid) {
        s.delsuper(mid);
        return ok();
    }

    //修改或添加演员
    @RequestMapping("/superadd")
    public ResultVO add(@RequestBody SuperStarBean superStar) {
        SuperStarBean add1 = s.add(superStar);
        return ok(add1);
    }

    //修改或添加电影
    @RequestMapping("/movieadd")
    public ResultVO addmovie(@RequestBody MovieBean movie) {
        MovieBean addm = s.addm(movie);
        return ok();
    }

    /*public boolean register(SuperStarBean supers){
        MovieBean role=new MovieBean();
        role.setMid((long) 2);
        Set<MovieBean> roles=new HashSet<MovieBean>();
        roles.add(role);
        supers.setMovies(movies); ;
        return userService.insert(supers);
    }*/

    //删除演员
    @RequestMapping("/superdelAll")
    public ResultVO superdelall(@RequestBody SuperStarBean superbean) {
        s.superdelall(superbean);
        return ok();
    }
    //删除电影
    @RequestMapping("/moviedelAll")
    public ResultVO moviedelall(@RequestBody MovieBean movieBean){
        s.moviedelall(movieBean);
        return ok();
    }
}

package com.allqj.calculator.service;

import com.allqj.calculator.entity.MovieBean;
import com.allqj.calculator.entity.SuperStarBean;

import java.util.List;

public interface ZmanyService {

    List<MovieBean> findAllbyMovie(MovieBean mb);

    List<SuperStarBean> findAllbySuper(SuperStarBean stom);

    void delmovie(String sid);

    void delsuper(String mid);

     SuperStarBean add(SuperStarBean superStar);

    MovieBean addm(MovieBean movie);

    SuperStarBean superdelall(SuperStarBean superbean);

    void moviedelall(MovieBean movieBean);
}

package com.allqj.calculator.service;
import com.allqj.calculator.entity.MovieBean;
import com.allqj.calculator.entity.SuperStarBean;
import com.allqj.calculator.repository.SuperRepository;
import com.allqj.calculator.repository.ZmanyRepository;
import com.allqj.calculator.repository.ZmanyRepositoryImpl;
import com.github.wenhao.jpa.Specifications;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Range;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;

/**
 * spec多表尝试Service层实现类
 *
 * @author Xing
 * @CREATE 2018-03-12-18:32
 */
@Service
public class ZmanyServiceImpl implements ZmanyService{
    @Autowired
    private ZmanyRepository movieDao;
    @Autowired
    private SuperRepository superDao;
    @Autowired
    private ZmanyRepositoryImpl zmanyRepositoryImpl;
    @Override
    @Modifying
    public List<MovieBean> findAllbyMovie(MovieBean mb) {
        Specification<MovieBean> specification = new Specifications<MovieBean>()
                //.between("age", new Range<>(10, 35))
                //.eq(Objects.nonNull(stom.getMovies()),"movie.mname", "666")
                .build();
        return movieDao.findAll();
    }
    @Override
    @Modifying
    public List<SuperStarBean> findAllbySuper(SuperStarBean stom) {
     Specification<SuperStarBean> specification = new Specifications<SuperStarBean>()
        .between("age", new Range<>(10, 35))
        .eq(Objects.nonNull(stom.getMovies()),"movie.mname", "666")
        .build();
    return superDao.findAll();
    }

    @Override
    public void delmovie(String sid) {
        zmanyRepositoryImpl.delmovie(sid);
    }

    @Override
    public void delsuper(String mid) {
        zmanyRepositoryImpl.delsuper(mid);
    }

     @Override
    public SuperStarBean add(SuperStarBean superStar) {
        return superDao.save(superStar);
    }

    @Override
    public MovieBean addm(MovieBean movie) {
        return movieDao.save(movie);
    }

    @Override
    public SuperStarBean superdelall(SuperStarBean superbean) {
        superDao.delete(superbean);
        return null;
    }

    @Override
    public void moviedelall(MovieBean movieBean) {
//        movieDao.deleteByMid("1");
//        zmanyRepositoryImpl.delete(movieBean);
    }
}

package com.allqj.calculator.repository;

import com.allqj.calculator.entity.MovieBean;
import com.allqj.calculator.entity.SuperStarBean;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import javax.transaction.Transactional;

public interface ZmanyRepository extends JpaRepository<MovieBean, Long>, JpaSpecificationExecutor<MovieBean> {


}

package com.allqj.calculator.repository;
import com.allqj.calculator.entity.MovieBean;
import com.allqj.calculator.entity.SuperStarBean;
import org.springframework.stereotype.Repository;
import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;
import javax.transaction.Transactional;

/**
 * @author Xing
 * @CREATE 2018-03-17-15:33
 */
@Repository
public class ZmanyRepositoryImpl {
    @PersistenceContext
    private EntityManager em;
    /**
     * 解除关联关系调用集合对象的remove方法
     * 集合的remove方法会删除的是关联关系，也就是删除中间表的某条记录
     * 但是，它不会删除实体类对应数据表中的记录
     */
    //解除演員信息中與某電影的關係
    @Transactional
    public void  delmovie(String sid){
        SuperStarBean superstar = em.find(SuperStarBean.class, sid);
        MovieBean item = superstar.getMovies().iterator().next();
        superstar.getMovies().remove(item);
    }
    //解除電影信息中與某演員的關係
    @Transactional
    public void delsuper(String mid) {
        MovieBean movie = em.find(MovieBean.class, mid);
        SuperStarBean item = movie.getSupers().iterator().next();
        movie.getSupers().remove(item);
    }
}