An example(User) sequence

UserRepository

public interface UserRepository extends JpaRepository<User, String> {
    
    @Query("SELECT DISTINCT e2.name FROM User u, Employee e1, Employee e2 WHERE u.employeeId = e1.employeeId AND e1.managerId = e2.employeeId AND u.userId=:uid")
    ArrayList<String> findManagerNameByUID(@Param("uid") String uid);
    
    @Query("SELECT u FROM User u WHERE u.name=:un AND u.password=:pwd")
    User findUserByNamePwd(@Param("un") String uname, @Param("pwd") String pwd);
}

UserService

public interface UserService {
    User findUser(String userId);
    User createUser(User user);
    User changeUser(User user);
    void removeUser(User user);
    
    ArrayList<String> findRoleNamesForUser(String userId);
    ArrayList<String> findManagerNameByUID(String userId);
    
    ArrayList<User> findAllUsers();
    ArrayList<Role> findRolesForUser(String userId);
    User authenticate(String uname, String pwd);
}

UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    
    @Resource
    private UserRepository userRepository;

    //JPA default method
    @Override
    @Transactional
    public ArrayList<User> findAllUsers() {
        ArrayList<User> ul = (ArrayList<User>) userRepository.findAll();
        return ul;
    }
    
    @Override
    @Transactional
    public User findUser(String userId) {
        return userRepository.findOne(userId);

    }

    @Override
    @Transactional
    public User createUser(User user) {
        return userRepository.saveAndFlush(user);
    }

    @Override
    @Transactional
    public User changeUser(User user) {
        return userRepository.saveAndFlush(user);
    }

    @Override
    @Transactional
    public void removeUser(User user) {
        userRepository.delete(user);
    }
    
    //new Query defined in userRepository 
    @Override
    @Transactional
    public ArrayList<String> findManagerNameByUID(String userId) {
        return userRepository.findManagerNameByUID(userId);
    }
    
    @Transactional
    public User authenticate(String uname, String pwd) {
        User u = userRepository.findUserByNamePwd(uname, pwd);
        return u;
    }
    
    //get the user model and use it's method 
    @Override
    @Transactional
    public ArrayList<Role> findRolesForUser(String userId) {
        return (ArrayList<Role>)userRepository.findOne(userId).getRoleSet();
    }
    
    @Override
    @Transactional
    public ArrayList<String> findRoleNamesForUser(String userId) {
        ArrayList<Role> rset =  (ArrayList<Role>) userRepository.findOne(userId).getRoleSet();
        ArrayList<String> rnames = new ArrayList<String>();
        for (Role role : rset) {
            rnames.add(role.getName());
        }
        return rnames;
    }
    
    @Override
    @Transactional
    public ArrayList<String> findRoleIdForUser(String userId) {
        ArrayList<String> getRoleIds =  (ArrayList<String>) userRepository.findOne(userId).getRoleIds();
        return getRoleIds;
    }
    
}

user model

Entity
@Table(name = "user")
public class User {
    @Id
    @Column(name = "userid")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private String userId;
    
    @NotNull
    @Temporal(TemporalType.DATE)
    @Column(name = "fromdate")
    @DateTimeFormat(pattern = "dd/MM/yyyy")

    @ManyToMany(targetEntity = Role.class, cascade = CascadeType.ALL, fetch=FetchType.EAGER)
    @JoinTable(name = "userrole", 
    joinColumns = {@JoinColumn(name = "userid", referencedColumnName = "userid") }, 
    inverseJoinColumns = {@JoinColumn(name = "roleid", referencedColumnName = "roleid") })
    private List<Role> roleSet;
    
    @Transient
    private ArrayList<String> roleIds = new ArrayList<String>();
    
    public List<Role> getRoleSet() {
        return roleSet;
    }
    public void setRoleSet(ArrayList<Role> roleSet) {
        this.roleSet = roleSet;
    }

    //just like predefined method for user
    public ArrayList<String> getRoleIds() {
        ArrayList<Role> rList = (ArrayList<Role>) this.getRoleSet();
        ArrayList<String> roleIds = new ArrayList<String>();
        for (Role role : rList) {
            roleIds.add(role.getRoleId());
        }
        return roleIds;
    }
    public void setRoleIds(ArrayList<String> roleIds) {

        this.roleIds = roleIds;
    }

Repository @Query

    @Query("SELECT e FROM Employee e where e.employeeId = :id")
    Employee findEmployeeById(@Param("id") String id);
    
    @Query("SELECT e FROM Employee e where e.managerId = :mgrid")
    ArrayList<Employee> findEmployeesByManagerId(@Param("mgrid") String mgrid);
    
    @Query("SELECT DISTINCT m FROM Employee e, Employee m where e.managerId = m.employeeId ")
    ArrayList<Employee> findAllManagers();

    @Query("SELECT DISTINCT m.name FROM Employee e, Employee m where e.managerId = m.employeeId ")
    ArrayList<String> findAllManagerNames();
    
    @Query("SELECT DISTINCT e2 FROM Employee e1, Employee e2 WHERE e1.employeeId = e2.managerId AND e1.employeeId = :eid")
    ArrayList<Employee> findSubordinates(@Param("eid") String eid);
    
    @Query("SELECT DISTINCT e.employeeId FROM Employee e")
    ArrayList<String> findAllEmployeeIDs();
    User findUserByNamePwd(@Param("un") String uname, @Param("pwd") String pwd);
   
    @Query("SELECT c from Course c WHERE c.employeeId = :eid AND (c.status ='SUBMITTED' OR c.status ='UPDATED')")
    ArrayList<Course> findPendingCoursesByEID(@Param("eid") String eid);
    
    @Query(value = "SELECT * FROM course WHERE status = ?0", nativeQuery = true)
    ArrayList<Course> findPendingCoursesByStatus(String status);

O/R Mapping Annotations

one to one (Stock --|---|-- StockDetail)

@Entity
@Table(name = "stock")
public class Stock implements java.io.Serializable {
    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "STOCK_ID", unique = true, nullable = false)
    private Integer stockId;
    
    @OneToOne(mappedBy = "stock")
    private StockDetail stockDetail;
}

@Entity
@Table(name = "stock_detail")
public class StockDetail implements java.io.Serializable {
    //...
    private Integer stockId;
    
    @OneToOne
    @PrimaryKeyJoinColumn
    private Stock stock;
}

one to many (Stock --|---<-- StockDailyRecord)

@Entity
@Table(name = "stock")
public class Stock implements java.io.Serializable {
    //...
    private Integer stockId;
    
    @OneToMany(mappedBy = "stock")
    private Set<StockDailyRecord> stockDailyRecords;
}

@Entity
@Table(name = "stock_detail")
public class StockDetail implements java.io.Serializable {
    //...
    private Integer recordId;
    
    @ManyToOne
    @JoinColumn(name = "STOCK_ID")
    private Stock stock;
}

many to many (Stock -->---<-- Category)

@Entity
@Table(name = "stock")
public class Stock implements java.io.Serializable {
    //...
    private Integer stockId;
    
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinTable(name = "stock_category",
        joinColumns = {@JoinColumn(name = "STOCK_ID"},
        inverseJoinColumns = { @JoinColumn(name = "CATEGORY_ID"})
    private Set<Category> categories;
}

@Entity
@Table(name = "category")
public class Category implements java.io.Serializable {
    //...
    private Integer categoryId;
    
    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "categories")
    private Set<Stock> stocks;
}