You can do something like this. You can make this code more generic so that you can use it for looping on fields:

Class aClass = f.getClass();
Class[] paramTypes = new Class[1];
paramTypes[0] = String.class; // get the actual param type

String methodName = "set" + fieldName; // fieldName String
Method m = null;
try {
    m = aClass.getMethod(methodName, paramTypes);
} catch (NoSuchMethodException nsme) {
    nsme.printStackTrace();
}

try {
    String result = (String) m.invoke(f, fieldValue); // field value
    System.out.println(result);
} catch (IllegalAccessException iae) {
    iae.printStackTrace();
} catch (InvocationTargetException ite) {
    ite.printStackTrace();
}

Have you tried getting all the methods of the invoked class and filtering out only the getter methods by name and invoking them?

 Method[] methods =  cls.getClass().getDeclaredMethods();

             for (Method m: methods) {
                 if(m.getName().startsWith("get")) {
                     m.invoke(clsInstance);
                 }
             }

This solves our half problem, as getters are invoked without any arguments. But if you need to invoke a setter method you need to specify arguments. Ex, To invoke a setter which accepts string argument method as below:

m.invoke(clsInstance, "some string argument");

One solution to could be make all the setters accept an object type value and typecast them while assigning it to actual class variables.

Now your pojo classes will look as below:

public class AccountPojo {

private String dataList;
private String dataSet;

public String getDataList() {
    return dataList;
}

public void setDataList(Object dataList) {
    this.dataList = (String) dataList;
}

public String getDataSet() {
    return dataSet;
}

public void setDataSet(Object dataSet) {
    this.dataSet = (String)dataSet;
}
} 

public class GetAccountsPojo {

private String accountId;
private int noOfAccounts;

public String getAccountId() {
    return accountId;
}

public void setAccountId(Object accountId) {
    this.accountId = (String) accountId;
}

public int getNoOfAccounts() {
    return noOfAccounts;
}

public void setNoOfAccounts(Object noOfAccounts) {
    this.noOfAccounts = (int) noOfAccounts;
}
}

Add below code to your main method:

for (Method m: methods) {
  if(m.getName().startsWith("get")) {
    m.invoke(clsInstance);
  }
  if(m.getName().startsWith("set")) {
    m.invoke(clsInstance, "any argument to be passed here");
  }

}

Use Lombok for that https://projectlombok.org/. It will generate boilerplate getter/setters for you on precompile.

it will be like

@Getter
@Setter
public class LombokExample(){
   private String myField;
}

done - end of class definition - no getters/setters required and still you will be able to

lombok=new LombokExample();
lombok.getMyField();
lombok.setMyField();

Java doesn't have a built-in means to add completely new methods. You could try an embedded scripting engine (http://docs.oracle.com/javase/6/docs/api/javax/script/package-summary.html), then using Javascript, jRuby, Groovy, etc.. Those languages will allow more runtime functionality along the lines of what you need and should be able to interact with your java code.

There are few things which I am assuming, because as per your details the question is somewhat unclear.

You have a database having records as per what you have mentioned in your question.

[
   {
       "userName": "Sita",
       "userEmail": "[email protected]",
       "January": 3,
       "February": 10,
       "March": 1,
       "April": 3,
       "May": 32,
       "June": 31
   }
]

Its basically Json Object contained inside Json Array, So, as per Java you will have a Entity class to hold the values and that Entity class will be contained inside a List.

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
class Details{
    private String userName;
    private String January;
    private String February;
    private String March;
    private String April;
    private String May;
    private String June;
    private String July;
    private String August;
    private String September;
    private String October;
    private String November;
    private String December;
}

Your result after fetching the data from database will be something like,

List<Details> result = //database call (Repository call);

Now, this all things will be happening inside some service class , we are calling that service class as DetailsServiceImpl.java

Repository

@Repository
interface DetailsRepository extends JpaRepository<Details,Long>{
    
}

Service

@Service
@RequiredArgsConstructor
class DetailsServiceImpl{
    private final DetailsRepository detailsRepository;
    
    public List<DetailsDto> getLastSixMonthsData(){
        //List<Details> result = //detailsRepository database call;

        //either use Modelmapper to copy the data from entity to DTO
        //BeanUtils can also be used.
        return //Copied ArrayList<DetailsDto>(); which will be populated by ModelMapper or BeanUtils.
    }
}

DTO This DTO is responsible for rendering the data to controller, or you can say sending the representable data to controller.

@Data
//@JsonInclude(JsonInclude.Include.NON_NULL) can be used if you dont want non-null values in your response.
class DetailsDto{
    private String userName;
    private String January;
    private String February;
    private String March;
    private String April;
    private String May;
    private String June;
    private String July;
    private String August;
    private String September;
    private String October;
    private String November;
    private String December;
}

RestController

@RestController
@RequiredArgsConstructor
class DetailsController{
    private final DetailsServiceImpl detailsService;
    public ResponseEntity<List<DetailsDto>> getDetailsLastSixMonths(){
        return new ResponseEntity<List<DetailsDto>>(detailsService.getLastSixMonthsData(), HttpStatus.OK);
    }
}

Links to follow How to use BeanUtils.copyProperties?

Copy one class properties to another class, with set the field to map in java Spring boot

No need to use JSONObject and operating on each object. Hope it helps.

I have the nagging feeling that it's not something you "should" do.

For starters, getters and setters are often used to provide some kind of field validation, or to return read-only views on the underlying field. More importantly, you will totally lose the ability to make thread-safe immutable classes instances using this approach. Sure, if you realized all you are dealing with are nothing more than a skeleton of getters and setters, this proxy-based approach might seem plausible, but you will be trading flexibility for functionality...

Code-wise, may I suggest that you flip the constructor-chaining of DataInvocationHandler so that the one will the least arguments 'pass-through' to the next?

DataInvocationHandler(final Class<?> interfaceClass) {
    this(interfaceClass, null);
}

DataInvocationHandler(final Class<?> interfaceClass, final Map<String, Object> variables) {
    this.interfaceClass = interfaceClass;
    if (variables != null) {
       this.variables.putAll(variables);
    }
}

It may not be applicable for DataInvocationHandler since it does not have final fields that needs to be set upon object instantiation, but flipping the constructor-chaining lets you centralize all the fields to set in one single constructor, eliminating compiler errors that tell you about fields not being set.

You can use your IDE to generate getter/setter methods. If you are using eclipse then you can do it by going to Source>generate methods.

Or alternatively you can use lombok generate getter setter method dynamically. In this case you don't even need to write your getter/setter methods. Look at the example -

import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;

public class Person {

   @Getter @Setter private String name;
   @Getter @Setter private int age = 10;
 }

If you can't create the getters and setters for some columns, you can add these columns into a specific or generic Map in the MedicineParam object.

MedicineParam additions:

private Map<String, String> attributes;

public void addAttribute(String attribute, String value) {
    if (this.attributes == null) {
        this.attributes = new HashMap<String, String>();
    }

    this.attributes.put(attribute, value);
}

public Map<String, String> getAttributes() {
    return attributes;
}

public void setAttributes(Map<String, String> attributes) {
    this.attributes = attributes;
}

In your while loop, use this:

if(rs.getString(attr) != null) {
    medici.addAttribute(attr, rs.getString(attr));
}

You can change the Map to be a Map<String, Object> to have a more generic map if you need to.

You can then get the values from the object:

medici.getAttributes().get("key");