//MediaPlayer.java 
public interface MediaPlayer { 
 public void play(String audioType, String fileName); 
} 

//AdvancedMediaPlayer.java 
public interface AdvancedMediaPlayer { 
 public void playVlc(String fileName); 
 public void playMp4(String fileName); 
} 

//VlcPlayer.java 
public class VlcPlayer implements AdvancedMediaPlayer{ 
 @Override 
 public void playVlc(String fileName) { 
 System.out.println("Playing vlc file. Name: "+ fileName); 
 } 
 
 @Override 
 public void playMp4(String fileName) { 
 //do nothing 
 } 
}

//Mp4Player.java 
public class Mp4Player implements AdvancedMediaPlayer{ 
 
 @Override 
 public void playVlc(String fileName) { 
 //do nothing 
 } 
 
 @Override 
 public void playMp4(String fileName) { 
 System.out.println("Playing mp4 file. Name: "+ fileName); 
 } 
} 

//MediaAdapter.java 
public class MediaAdapter implements MediaPlayer { 
 
 AdvancedMediaPlayer advancedMusicPlayer; 
 
 public MediaAdapter(String audioType){ 
 if(audioType.equalsIgnoreCase("vlc") ){ 
 advancedMusicPlayer = new VlcPlayer(); 
 } else if (audioType.equalsIgnoreCase("mp4")){ 
 advancedMusicPlayer = new Mp4Player(); 
 } 
 } 
 
 @Override 
 public void play(String audioType, String fileName) { 
 if(audioType.equalsIgnoreCase("vlc")){ 
 advancedMusicPlayer.playVlc(fileName); 
 }else if(audioType.equalsIgnoreCase("mp4")){ 
 advancedMusicPlayer.playMp4(fileName); 
 } 
 } 
} 

//AudioPlayer.java 
public class AudioPlayer implements MediaPlayer { 
 MediaAdapter mediaAdapter; 
 
 @Override 
 public void play(String audioType, String fileName) { 
 
 //inbuilt support to play mp3 music files 
 if(audioType.equalsIgnoreCase("mp3")){ 
 System.out.println("Playing mp3 file. Name: "+ fileName); 
 } 
 //mediaAdapter is providing support to play other file 
formats 
 else if(audioType.equalsIgnoreCase("vlc") 
 || audioType.equalsIgnoreCase("mp4")){ 
 mediaAdapter = new MediaAdapter(audioType); 
 mediaAdapter.play(audioType, fileName); 
 } 
 else{ 
 System.out.println("Invalid media. "+ 
 audioType + " format not supported"); 
 } 
 } 

//AdapterPatternDemo.java 
public class AdapterPatternDemo { 
 public static void main(String[] args) { 
 AudioPlayer audioPlayer = new AudioPlayer(); 
 
 audioPlayer.play("mp3", "beyond the horizon.mp3"); 
 audioPlayer.play("mp4", "alone.mp4"); 
 audioPlayer.play("vlc", "far far away.vlc"); 
 audioPlayer.play("avi", "mind me.avi"); 
 } 
} 

//Verify the output. 
Playing mp3 file. Name: beyond the horizon.mp3 
Playing mp4 file. Name: alone.mp4 
Playing vlc file. Name: far far away.vlc 
Invalid media. avi format not supported 

public interface DrawAPI { 
 public void drawCircle(int radius, int x, int y); 
} 

public class RedCircle implements DrawAPI { 
 @Override 
 public void drawCircle(int radius, int x, int y) { 
 System.out.println("Drawing Circle[ color: red, radius: " 
 + radius +", x: " +x+", "+ y +"]"); 
 } 
} 

public class GreenCircle implements DrawAPI { 
 @Override 
 public void drawCircle(int radius, int x, int y) { 
 System.out.println("Drawing Circle[ color: green, radius: " 
 + radius +", x: " +x+", "+ y +"]"); 
 } 
} 
 

public abstract class Shape { 
 protected DrawAPI drawAPI; 
 protected Shape(DrawAPI drawAPI){ 
 this.drawAPI = drawAPI; 
 } 
 public abstract void draw(); 
} 

public class Circle extends Shape { 
 private int x, y, radius; 
 
 public Circle(int x, int y, int radius, DrawAPI drawAPI) { 
 super(drawAPI); 
 this.x = x; 
 this.y = y; 
 this.radius = radius; 
 } 
 
 public void draw() { 
 drawAPI.drawCircle(radius,x,y); 
 } 
}

public class BridgePatternDemo { 
 public static void main(String[] args) { 
 Shape redCircle = new Circle(100,100, 10, new RedCircle()); 
 Shape greenCircle = new Circle(100,100, 10, new GreenCircle()); 
 
 redCircle.draw(); 
 greenCircle.draw(); 
 } 
} 

Drawing Circle[ color: red, radius: 10, x: 100, 100] 
Drawing Circle[ color: green, radius: 10, x: 100, 100]

public class Person { 
 
 private String name; 
 private String gender; 
 private String maritalStatus; 
 
 public Person(String name,String gender,String maritalStatus){ 
 this.name = name; 
 this.gender = gender; 
 this.maritalStatus = maritalStatus; 
 } 
 
 public String getName() { 
 return name; 
 } 
 public String getGender() { 
 return gender; 
 } 
 public String getMaritalStatus() { 
 return maritalStatus; 
 } 
} 

import java.util.List; 
 
public interface Criteria { 
 public List<Person> meetCriteria(List<Person> persons); 
} 

import java.util.ArrayList; 
import java.util.List; 
 
public class CriteriaMale implements Criteria { 
 
 @Override 
 public List<Person> meetCriteria(List<Person> persons) { 
 List<Person> malePersons = new ArrayList<Person>(); 
 for (Person person : persons) { 
 if(person.getGender().equalsIgnoreCase("MALE")){ 
 malePersons.add(person); 
 } 
 } 
 return malePersons; 
 } 
} 

import java.util.ArrayList; 
import java.util.List; 
 
public class CriteriaFemale implements Criteria { 
 
 @Override 
 public List<Person> meetCriteria(List<Person> persons) { 
 List<Person> femalePersons = new ArrayList<Person>(); 
 for (Person person : persons) { 
 if(person.getGender().equalsIgnoreCase("FEMALE")){ 
 femalePersons.add(person); 
 } 
 } 
 return femalePersons; 
 } 
}

import java.util.List; 
 
public class AndCriteria implements Criteria { 
 
 private Criteria criteria; 
 private Criteria otherCriteria; 
 
 public AndCriteria(Criteria criteria, Criteria otherCriteria) { 
 this.criteria = criteria; 
 this.otherCriteria = otherCriteria; 
 } 
 
 @Override 
 public List<Person> meetCriteria(List<Person> persons) { 
 List<Person> firstCriteriaPersons = 
criteria.meetCriteria(persons); 
 return otherCriteria.meetCriteria(firstCriteriaPersons); 
 } 
} 

import java.util.List; 
 
public class AndCriteria implements Criteria { 
 
 private Criteria criteria; 
 private Criteria otherCriteria; 
 
 public AndCriteria(Criteria criteria, Criteria otherCriteria) { 
 this.criteria = criteria; 
 this.otherCriteria = otherCriteria; 
 } 
 
 @Override 
 public List<Person> meetCriteria(List<Person> persons) { 
 List<Person> firstCriteriaItems = criteria.meetCriteria(persons); 
 List<Person> otherCriteriaItems = 
otherCriteria.meetCriteria(persons); 
 
 for (Person person : otherCriteriaItems) { 
 if(!firstCriteriaItems.contains(person)){ 
 firstCriteriaItems.add(person); 
 } 
 } 
 return firstCriteriaItems; 
 } 
} 

public class CriteriaPatternDemo { 
 public static void main(String[] args) { 
 List<Person> persons = new ArrayList<Person>(); 
 
 persons.add(new Person("Robert","Male", "Single")); 
 persons.add(new Person("John","Male", "Married")); 
 persons.add(new Person("Laura","Female", "Married")); 
 persons.add(new Person("Diana","Female", "Single")); 
 persons.add(new Person("Mike","Male", "Single")); 
 persons.add(new Person("Bobby","Male", "Single")); 
 
 Criteria male = new CriteriaMale(); 
 Criteria female = new CriteriaFemale(); 
 Criteria single = new CriteriaSingle(); 
 Criteria singleMale = new AndCriteria(single, male); 
 Criteria singleOrFemale = new OrCriteria(single, female); 
 
 System.out.println("Males: "); 
 printPersons(male.meetCriteria(persons)); 
 
 System.out.println("\nFemales: "); 
 printPersons(female.meetCriteria(persons)); 
 
 System.out.println("\nSingle Males: "); 
 printPersons(singleMale.meetCriteria(persons)); 
 
 System.out.println("\nSingle Or Females: "); 
 printPersons(singleOrFemale.meetCriteria(persons)); 
 } 
 
 public static void printPersons(List<Person> persons){ 
 for (Person person : persons) { 
 System.out.println("Person : [ Name : " + person.getName() 
 +", Gender : " + person.getGender() 
 +", Marital Status : " + person.getMaritalStatus() 
 +" ]"); 
 } 
 } 
}

Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] 
Person : [ Name : John, Gender : Male, Marital Status : Married ]  

Person : [ Name : Mike, Gender : Male, Marital Status : Single ] 
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ] 
 
Females: 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ] 
Person : [ Name : Diana, Gender : Female, Marital Status : Single ] 
 
Single Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] 
Person : [ Name : Mike, Gender : Male, Marital Status : Single ] 
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ] 
 
Single Or Females: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ] 
Person : [ Name : Diana, Gender : Female, Marital Status : Single ] 
Person : [ Name : Mike, Gender : Male, Marital Status : Single ] 
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ] 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ] 

@Data
public class MethodResult<T> {

    private enum Status {
        SUCCESS, ERROR;
    }

    @Getter(AccessLevel.NONE)
    private Status status;
    private T result;
    private ApiError error;

    public boolean isSuccess(){
        return status == Status.SUCCESS;
    }

    private MethodResult(){}

    public static MethodResult success(Object result) {
        MethodResult methodResult = new MethodResult();
        methodResult.setStatus(Status.SUCCESS);
        methodResult.setResult(result);
        return methodResult;
    }

    public static MethodResult error(String error) {
        MethodResult methodResult = new MethodResult();
        methodResult.setStatus(Status.ERROR);
        methodResult.setError(new ApiError(error));
        return methodResult;
    }


}

@Override
    public List<Document> document() {
        Map<String, BeanWithMethod> map = beanAnnotationMethods.getBeansAnnotatedMethods();
        List<Document> documents = new ArrayList<>();

        map.forEach((k,v)->{
            Document document = new Document();
            document.setMethodName(k);

            List<Parameter> Parameters = new ArrayList<>();
            for(Parameter parameter : v.getMethod().getParameters()){
                if(!parameter.getType().equals(User.class)) {
                    Parameter parameter = new Parameter();
                    parameter.setName(parameter.getName());
                    if(isSimpleObject(parameter.getType()))
                        parameter.setType(parameter.getType().getTypeName());
                    else if(isEnum(v.getMethod().getReturnType()))
                        parameter.setType("{" + Arrays.stream(v.getMethod().getReturnType().getEnumConstants())
                                .map(Object::toString)
                                .collect(Collectors.joining(", ")) + "}");
                    else
                        parameter.setParameters(getParamsFromComplexClass(parameter.getType()));
                    parameters.add(parameter);
                }
            }

            document.setInParams(parameters);

            Parameter outParam = new Parameter();
            outParam.setName("return");
            if(isSimpleObject(v.getMethod().getReturnType()))
                outParam.setType(v.getMethod().getReturnType().getSimpleName());
            else if(isEnum(v.getMethod().getReturnType()))
                outParam.setType("{" + Arrays.stream(v.getMethod().getReturnType().getEnumConstants())
                        .map(Object::toString)
                        .collect(Collectors.joining(", ")) + "}");
            else
                outParam.setParameters(getParamsFromMethod(v.getMethod()));


            document.setOutParam(outParam);

            documents.add(document);
        });

        return documents;
    }

package com.gieman.tttracker.vo;
  import java.io.Serializable;
  import java.util.List;
  import java.util.Objects;


public class Result<T> implements Serializable {
      final private boolean success;
      final private T data;
      final private String msg;

Result(boolean success, T data) {
   this.success = success;
   this.data = data;
   this.msg = null;
}

Result(boolean success, String msg) {
    this.success = success;
    this.data = null;
    this.msg = msg;
}

public boolean isSuccess() {
    return success;
}

public T getData() {
  return data;
}

public String getMsg() {
  return msg;
}

package com.gieman.tttracker.vo;
public class ResultFactory {
   public static <T> Result<T> getSuccessResult(T data) {
        return new Result(true, data);
   }


 public static <T> Result<T> getSuccessResult(T data, String msg) {
           return new Result(true, msg);
}

public static <T> Result<T> getSuccessResultMsg(String msg) {
     return new Result(true, msg);
 }

public static <T> Result<T> getFailResult(String msg) {
   return new Result(false, msg);
 }

}