diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 08988149..68cae27e 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -16,10 +16,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up JDK 11
+    - name: Set up JDK 17
       uses: actions/setup-java@v3
       with:
-        java-version: '11'
+        java-version: '17'
         distribution: 'temurin'
         cache: maven
     - uses: s4u/maven-settings-action@v2.6.0
diff --git a/.run/All Tests.run.xml b/.run/All Tests.run.xml
index 8b59ba67..292c91f5 100644
--- a/.run/All Tests.run.xml	
+++ b/.run/All Tests.run.xml	
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="All Tests" type="JUnit" factoryName="JUnit">
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
-    <option name="ALTERNATIVE_JRE_PATH" value="1.8" />
+    <option name="ALTERNATIVE_JRE_PATH" value="17" />
     <option name="MAIN_CLASS_NAME" value="" />
     <option name="METHOD_NAME" value="" />
     <option name="TEST_OBJECT" value="pattern" />
diff --git a/README.md b/README.md
index e388ad62..e7b068a1 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,9 @@ Here is an overview of the module dependencies:
 
     lis-commons-beans (0 deps)
 
+    lis-commons-beans-record (1 deps)
+    +- lis-commons-beans
+
     lis-commons-lang-criteria (3 deps)
     +- lis-commons-lang
     +- lis-commons-util
@@ -80,6 +83,23 @@ will output
     button model changed.
     button model armed: true
 
+# [lis-commons-beans-records](lis-commons-beans-records/README.md)
+
+Beans support for Java records.
+
+    public record PersonRecord(String firstname, String lastname) {}
+
+       
+    BeansFactory beansFactory = BeansFactory.getInstance("record");
+    Bean<Person> bean = beansFactory.createBean(new PersonRecord("René", "Link"));
+    PropertyList properties = bean.getProperties();
+
+    assertEquals("René", properties.getByName("firstname").getValue());
+    assertEquals("Link", properties.getByName("lastname").getValue());
+
+Details at [lis-commons-beans-records](lis-commons-beans-records/README.md).
+
+
 # lis-commons-jdbc
 
 Provides a convenient api to access the meta-data of a jdbc connection
diff --git a/lis-commons-beans-records/README.md b/lis-commons-beans-records/README.md
new file mode 100644
index 00000000..34fe0c67
--- /dev/null
+++ b/lis-commons-beans-records/README.md
@@ -0,0 +1,90 @@
+# lis-commons-beans-records
+
+An extension library for the lis-commons-beans lib to handle Java records like beans.
+
+## Usage
+
+Let's assume you have a PersonRecord like this:
+
+    public record PersonRecord(String firstname, String lastname) {
+   
+       PersonRecord() {
+           this("unknown", "unknown");
+       }
+    }
+
+You can then get an instance of the record BeansFactory by using the name "record":
+ 
+    BeansFactory beansFactory = BeansFactory.getInstance("record");
+
+This factory will create BeanClass instances that can handle Java records:
+
+    BeanClass<PersonRecord> personRecordBeanClass = beansFactory.createBeanClass(PersonRecord.class);
+
+    PersonRecord personRecord = new PersonRecord("René", "Link");
+    Bean<PersonRecord> personRecordBean = personRecordBeanClass.getBeanFromInstance(personRecord);
+
+    PropertyList properties = personRecordBean.getProperties();
+
+    Property firstnameProperty = properties.getByName("firstname");
+    assertEquals("René", firstnameProperty.getValue());
+
+    Property lastnameProperty = properties.getByName("lastname");
+    assertEquals("Link", lastnameProperty.getValue());
+
+
+    public record PersonRecord(String firstname, String lastname) {}
+
+       
+    BeansFactory beansFactory = BeansFactory.getInstance("record");
+    Bean<Person> bean = beansFactory.createBean(new PersonRecord("René", "Link"));
+    PropertyList properties = bean.getProperties();
+
+    assertEquals("René", properties.getByName("firstname").getValue());
+    assertEquals("Link", properties.getByName("lastname").getValue());
+
+You can also copy a record's values to another bean.
+
+Let's assume you hava a Java record named `PersonRecord`
+
+    public record PersonRecord(String firstname, String lastname) {}
+
+and a Java bean names `PersonBean`
+
+    public class PersonBean {
+    
+        private String firstname;
+        private String lastname;
+    
+        public String getFirstname() {
+            return firstname;
+        }
+    
+        public void setFirstname(String firstname) {
+            this.firstname = firstname;
+        }
+    
+        public String getLastname() {
+            return lastname;
+        }
+    
+        public void setLastname(String lastname) {
+            this.lastname = lastname;
+        }
+    }
+
+you can then copy the "properties" (record values) from the `PersonRecord` to the `PersonBean` by using different BeanFactory instances.
+
+    BeansFactory recordBeansFactory = BeansFactory.getInstance("record");
+    PersonRecord personRecord = new PersonRecord("René", "Link");
+    Bean<Person> recordBean = recordBeansFactory.createBean(personRecord);
+
+    BeansFactory javaBeansFactory = BeansFactory.getInstance("java"); // the default if no name is provided
+    PersonBean personJavaBean = new PersonBean();
+    Bean<PersonBean> javaBean = javaBeansFactory.createBean(personJavaBean);
+
+    recordBean.getProperties().copy(javaBean.getProperties());
+
+    assertEquals("René", personJavaBean.getFirstname());
+    assertEquals("Link", personJavaBean.getLastname());
+
diff --git a/lis-commons-beans-records/pom.xml b/lis-commons-beans-records/pom.xml
new file mode 100644
index 00000000..5b7ae0f0
--- /dev/null
+++ b/lis-commons-beans-records/pom.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.link-intersystems.commons</groupId>
+        <artifactId>lis-commons</artifactId>
+        <version>1.9.7-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>lis-commons-beans-records</artifactId>
+    <name>LIS Commons Beans Records</name>
+    <description>A lis-commons-beans provider that allows you to access Java records through the bean api.</description>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.link-intersystems.commons</groupId>
+            <artifactId>lis-commons-beans</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/Introspector.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/Introspector.java
new file mode 100644
index 00000000..b02ff6e4
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/Introspector.java
@@ -0,0 +1,11 @@
+package com.link_intersystems.beans.java.record;
+
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+
+public class Introspector {
+
+    public static BeanInfo getBeanInfo(Class<?> recordType) throws IntrospectionException {
+        return new RecordBeanInfo(recordType);
+    }
+}
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBean.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBean.java
new file mode 100644
index 00000000..ddfddce7
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBean.java
@@ -0,0 +1,12 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.java.JavaBean;
+import com.link_intersystems.beans.java.JavaBeanClass;
+
+public class RecordBean<T> extends JavaBean<T> {
+
+    protected RecordBean(JavaBeanClass<T> beanClass, T bean) {
+        super(beanClass, bean);
+    }
+
+}
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanClass.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanClass.java
new file mode 100644
index 00000000..ee603394
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanClass.java
@@ -0,0 +1,23 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.BeanInstanceFactory;
+import com.link_intersystems.beans.java.JavaBeanClass;
+
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+
+public class RecordBeanClass<T> extends JavaBeanClass<T> {
+
+    protected RecordBeanClass(Class<T> beanClass) throws IntrospectionException {
+        this(Introspector.getBeanInfo(beanClass));
+    }
+
+    protected RecordBeanClass(BeanInfo recordBeanInfo) {
+        super(recordBeanInfo);
+    }
+
+    @Override
+    public BeanInstanceFactory<T> getBeanInstanceFactory() {
+        return new RecordBeanInstanceFactory<>(this);
+    }
+}
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInfo.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInfo.java
new file mode 100644
index 00000000..393004dd
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInfo.java
@@ -0,0 +1,43 @@
+package com.link_intersystems.beans.java.record;
+
+import java.beans.BeanDescriptor;
+import java.beans.IntrospectionException;
+import java.beans.PropertyDescriptor;
+import java.beans.SimpleBeanInfo;
+import java.lang.reflect.RecordComponent;
+
+class RecordBeanInfo extends SimpleBeanInfo {
+
+    private final BeanDescriptor beanDescriptor;
+    private PropertyDescriptor[] propertyDescriptors;
+
+    public RecordBeanInfo(Class<?> recordClass) throws IntrospectionException {
+        if (!recordClass.isRecord()) {
+            throw new IntrospectionException(recordClass + " is not a Java record.");
+        }
+
+        beanDescriptor = new BeanDescriptor(recordClass);
+        propertyDescriptors = createPropertyDescriptors(recordClass.getRecordComponents());
+    }
+
+    private PropertyDescriptor[] createPropertyDescriptors(RecordComponent[] recordComponents) throws IntrospectionException {
+        PropertyDescriptor[] descriptors = new PropertyDescriptor[recordComponents.length];
+
+        for (int i = 0; i < recordComponents.length; i++) {
+            RecordComponent recordComponent = recordComponents[i];
+            descriptors[i] = new PropertyDescriptor(recordComponent.getName(), recordComponent.getAccessor(), null);
+        }
+
+        return descriptors;
+    }
+
+    @Override
+    public BeanDescriptor getBeanDescriptor() {
+        return beanDescriptor;
+    }
+
+    @Override
+    public PropertyDescriptor[] getPropertyDescriptors() {
+        return propertyDescriptors.clone();
+    }
+}
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactory.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactory.java
new file mode 100644
index 00000000..dce48c51
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactory.java
@@ -0,0 +1,67 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.*;
+import com.link_intersystems.beans.java.JavaBeanClass;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Parameter;
+import java.util.concurrent.Callable;
+
+import static java.util.Objects.requireNonNull;
+
+class RecordBeanInstanceFactory<T> implements BeanInstanceFactory<T> {
+
+    private JavaBeanClass<T> beanClass;
+
+    RecordBeanInstanceFactory(JavaBeanClass<T> beanClass) {
+        this.beanClass = requireNonNull(beanClass);
+    }
+
+    @Override
+    public Bean<T> newBeanInstance(ArgumentResolver argumentResolver) {
+
+        try {
+            Callable<T> newInstanceCallable = resolveNewInstanceCallable(argumentResolver);
+            if (newInstanceCallable == null) {
+                throw new BeanInstantiationException("No constructor resolvable for " + beanClass);
+            }
+
+            try {
+                T bean = newInstanceCallable.call();
+                return fromExistingInstance(bean);
+            } catch (Exception e) {
+                throw new BeanInstantiationException("Unable to create a record bean.", e);
+            }
+        } catch (ArgumentResolveException e) {
+            throw new BeanInstantiationException("No constructor resolvable for " + beanClass, e);
+        }
+    }
+
+    protected Callable<T> resolveNewInstanceCallable(ArgumentResolver argumentResolver) throws ArgumentResolveException {
+        Class<T> type = beanClass.getType();
+
+        try {
+            Constructor<T> defaultConstructor = type.getDeclaredConstructor();
+            return () -> defaultConstructor.newInstance();
+        } catch (NoSuchMethodException e) {
+            Constructor<?>[] declaredConstructors = type.getDeclaredConstructors();
+
+            for (Constructor<?> constructor : declaredConstructors) {
+                Parameter[] parameters = constructor.getParameters();
+                if (argumentResolver.canResolveArguments(parameters)) {
+                    Object[] arguments = argumentResolver.resolveArguments(parameters);
+                    if (arguments != null && arguments.length == parameters.length) {
+                        return () -> (T) constructor.newInstance(arguments);
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public Bean<T> fromExistingInstance(T beanObject) {
+        return new RecordBean<>(beanClass, beanObject);
+    }
+}
diff --git a/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeansFactory.java b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeansFactory.java
new file mode 100644
index 00000000..703d6104
--- /dev/null
+++ b/lis-commons-beans-records/src/main/java/com/link_intersystems/beans/java/record/RecordBeansFactory.java
@@ -0,0 +1,27 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.BeanClass;
+import com.link_intersystems.beans.BeanClassException;
+import com.link_intersystems.beans.BeansFactory;
+
+import java.beans.IntrospectionException;
+
+public class RecordBeansFactory extends BeansFactory {
+    @Override
+    public String getTypeName() {
+        return "record";
+    }
+
+    @Override
+    public <T> BeanClass<T> createBeanClass(Class<T> beanClass, Class<?> stopClass) throws BeanClassException {
+        /**
+         * Ignoring stopClass, because records can not create an inheritance hierarchy.
+         * See Java 17 JLS 8.10 https://docs.oracle.com/javase/specs/jls/se17/html/jls-8.html#jls-8.10
+         */
+        try {
+            return new RecordBeanClass<>(beanClass);
+        } catch (IntrospectionException e) {
+            throw new BeanClassException("Unable to create record bean class", e);
+        }
+    }
+}
diff --git a/lis-commons-beans-records/src/main/resources/META-INF/services/com.link_intersystems.beans.BeansFactory b/lis-commons-beans-records/src/main/resources/META-INF/services/com.link_intersystems.beans.BeansFactory
new file mode 100644
index 00000000..9b98b8b5
--- /dev/null
+++ b/lis-commons-beans-records/src/main/resources/META-INF/services/com.link_intersystems.beans.BeansFactory
@@ -0,0 +1 @@
+com.link_intersystems.beans.java.record.RecordBeansFactory
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/IntrospectorTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/IntrospectorTest.java
new file mode 100644
index 00000000..88030172
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/IntrospectorTest.java
@@ -0,0 +1,26 @@
+package com.link_intersystems.beans.java.record;
+
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IntrospectorTest {
+
+    @Test
+    void getBeanInfo() throws IntrospectionException {
+        BeanInfo beanInfo = Introspector.getBeanInfo(PersonRecord.class);
+
+        assertEquals("PersonRecord", beanInfo.getBeanDescriptor().getName());
+        assertEquals("firstname", beanInfo.getPropertyDescriptors()[0].getName());
+        assertEquals("lastname", beanInfo.getPropertyDescriptors()[1].getName());
+    }
+
+    @Test
+    void getBeanInfoNotRecord() {
+        assertThrows(IntrospectionException.class, () -> Introspector.getBeanInfo(DefaultListModel.class));
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonBean.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonBean.java
new file mode 100644
index 00000000..bdcaca08
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonBean.java
@@ -0,0 +1,23 @@
+package com.link_intersystems.beans.java.record;
+
+public class PersonBean {
+
+    private String firstname;
+    private String lastname;
+
+    public String getFirstname() {
+        return firstname;
+    }
+
+    public void setFirstname(String firstname) {
+        this.firstname = firstname;
+    }
+
+    public String getLastname() {
+        return lastname;
+    }
+
+    public void setLastname(String lastname) {
+        this.lastname = lastname;
+    }
+}
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonRecord.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonRecord.java
new file mode 100644
index 00000000..b13f8e41
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/PersonRecord.java
@@ -0,0 +1,8 @@
+package com.link_intersystems.beans.java.record;
+
+public record PersonRecord(String firstname, String lastname) {
+
+    PersonRecord() {
+        this("unknown", "unknown");
+    }
+}
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanClassTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanClassTest.java
new file mode 100644
index 00000000..cfe6745d
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanClassTest.java
@@ -0,0 +1,44 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.BeanClass;
+import com.link_intersystems.beans.PropertyDescList;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.beans.IntrospectionException;
+import java.lang.reflect.Constructor;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordBeanClassTest {
+
+    private BeanClass<PersonRecord> bean;
+
+    @BeforeEach
+    void setUp() throws IntrospectionException {
+        bean = new RecordBeanClass<>(PersonRecord.class);
+    }
+
+    @Test
+    void getName() {
+        assertEquals("PersonRecord", bean.getName());
+    }
+
+    @Test
+    void getType() {
+        assertEquals(PersonRecord.class, bean.getType());
+    }
+
+    @Test
+    void getBeanInstanceFactory() {
+
+        assertInstanceOf(RecordBeanInstanceFactory.class, bean.getBeanInstanceFactory());
+    }
+
+    @Test
+    void getAllProperties() {
+        PropertyDescList allProperties = bean.getAllProperties();
+
+        assertEquals(2, allProperties.size());
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactoryTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactoryTest.java
new file mode 100644
index 00000000..719c5bac
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanInstanceFactoryTest.java
@@ -0,0 +1,135 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.beans.IntrospectionException;
+import java.lang.reflect.Parameter;
+import java.util.concurrent.Callable;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.spy;
+
+class RecordBeanInstanceFactoryTest {
+
+    private ArgumentResolver argumentResolver;
+    private RecordBeanClass<PersonRecord> personRecordBeanClass;
+
+    public static record RecordWithoutDefaultConstructor(String value) {
+    }
+
+    private BeanInstanceFactory<PersonRecord> beanInstanceFactory;
+
+    @BeforeEach
+    void setUp() throws IntrospectionException {
+        argumentResolver = spy(ArgumentResolver.class);
+        personRecordBeanClass = new RecordBeanClass<>(PersonRecord.class);
+        beanInstanceFactory = new RecordBeanInstanceFactory<>(personRecordBeanClass);
+    }
+
+    @Test
+    void newBeanInstance() {
+        Bean<PersonRecord> personBean = beanInstanceFactory.newBeanInstance();
+        assertInstanceOf(RecordBean.class, personBean);
+    }
+
+    @Test
+    void newBeanInstanceWithArgumentResolver() throws IntrospectionException {
+        RecordBeanClass<RecordWithoutDefaultConstructor> beanClass = new RecordBeanClass<>(RecordWithoutDefaultConstructor.class);
+        ArgumentResolver argumentResolver = new ArgumentResolver() {
+            @Override
+            public boolean canResolveArgument(Parameter parameter) {
+                return true;
+            }
+
+            @Override
+            public Object resolveArgument(Parameter parameter) throws ArgumentResolveException {
+                try {
+
+                    if (parameter.equals(RecordWithoutDefaultConstructor.class.getDeclaredConstructor(String.class).getParameters()[0])) {
+                        return "someValue";
+                    }
+                    return null;
+                } catch (Exception e) {
+                    throw new ArgumentResolveException(e);
+                }
+            }
+        };
+
+        RecordBeanInstanceFactory<RecordWithoutDefaultConstructor> instanceFactory = new RecordBeanInstanceFactory<>(beanClass);
+
+
+        Bean<RecordWithoutDefaultConstructor> bean = instanceFactory.newBeanInstance(argumentResolver);
+        assertInstanceOf(RecordBean.class, bean);
+
+        RecordWithoutDefaultConstructor beanObject = bean.getBeanObject();
+        assertEquals("someValue", beanObject.value());
+    }
+
+    @Test
+    void unresolveableConstructor() throws IntrospectionException {
+        RecordBeanClass<RecordWithoutDefaultConstructor> beanClass = new RecordBeanClass<>(RecordWithoutDefaultConstructor.class);
+        ArgumentResolver argumentResolver = new ArgumentResolver() {
+            @Override
+            public boolean canResolveArgument(Parameter parameter) {
+                return false;
+            }
+
+            @Override
+            public Object resolveArgument(Parameter parameter) {
+                return null;
+            }
+        };
+        RecordBeanInstanceFactory<RecordWithoutDefaultConstructor> instanceFactory = new RecordBeanInstanceFactory<>(beanClass);
+
+
+        assertThrows(BeanInstantiationException.class, () -> instanceFactory.newBeanInstance(argumentResolver));
+    }
+
+    @Test
+    void argumentResolverException() throws IntrospectionException {
+        RecordBeanClass<RecordWithoutDefaultConstructor> beanClass = new RecordBeanClass<>(RecordWithoutDefaultConstructor.class);
+        ArgumentResolver argumentResolver = new ArgumentResolver() {
+            @Override
+            public boolean canResolveArgument(Parameter parameter) {
+                return true;
+            }
+
+            @Override
+            public Object resolveArgument(Parameter parameter) throws ArgumentResolveException {
+                throw new ArgumentResolveException("");
+            }
+        };
+
+        RecordBeanInstanceFactory<RecordWithoutDefaultConstructor> instanceFactory = new RecordBeanInstanceFactory<>(beanClass);
+
+
+        assertThrows(BeanInstantiationException.class, () -> instanceFactory.newBeanInstance(argumentResolver));
+    }
+
+
+    @Test
+    void constructorThrowsException() {
+        Exception exception = new InstantiationException();
+        beanInstanceFactory = new RecordBeanInstanceFactory<>(personRecordBeanClass) {
+            @Override
+            protected Callable<PersonRecord> resolveNewInstanceCallable(ArgumentResolver argumentResolver) {
+                return () -> {
+                    throw exception;
+                };
+            }
+        };
+
+
+        BeanInstantiationException beanInstantiationException = assertThrows(BeanInstantiationException.class, () -> beanInstanceFactory.newBeanInstance(argumentResolver));
+        assertEquals(exception, beanInstantiationException.getCause());
+    }
+
+    @Test
+    void fromExistingInstance() {
+        PersonRecord personRecord = new PersonRecord("René", "Link");
+        Bean<PersonRecord> personBean = beanInstanceFactory.fromExistingInstance(personRecord);
+        assertInstanceOf(RecordBean.class, personBean);
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanTest.java
new file mode 100644
index 00000000..e22c5f2e
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeanTest.java
@@ -0,0 +1,19 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.PropertyList;
+import org.junit.jupiter.api.Test;
+
+import java.beans.IntrospectionException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordBeanTest {
+
+    @Test
+    void getAllProperties() throws IntrospectionException {
+        RecordBean<PersonRecord> bean = new RecordBean<>(new RecordBeanClass<>(PersonRecord.class), new PersonRecord("René", "Link"));
+
+        PropertyList allProperties = bean.getAllProperties();
+        assertEquals(2, allProperties.size());
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeansFactoryTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeansFactoryTest.java
new file mode 100644
index 00000000..8bedbb6b
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordBeansFactoryTest.java
@@ -0,0 +1,41 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.BeanClassException;
+import com.link_intersystems.beans.BeansFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.beans.IntrospectionException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordBeansFactoryTest {
+
+    private BeansFactory beansFactory;
+
+    @BeforeEach
+    void setUp() {
+        beansFactory = BeansFactory.getInstance("record");
+    }
+
+    @Test
+    void recordBeansFactoryDiscovery() {
+        assertNotNull(beansFactory);
+    }
+
+    @Test
+    void createBeanClass() {
+        BeansFactory beansFactory = BeansFactory.getInstance("record");
+        assertInstanceOf(RecordBeanClass.class, beansFactory.createBeanClass(PersonRecord.class));
+    }
+
+
+    @Test
+    void createBeanClassNoRecord() {
+        BeansFactory beansFactory = BeansFactory.getInstance("record");
+
+        BeanClassException beanClassException = assertThrows(BeanClassException.class, () -> beansFactory.createBeanClass(PersonBean.class));
+
+        assertInstanceOf(IntrospectionException.class, beanClassException.getCause());
+    }
+}
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordExamplesTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordExamplesTest.java
new file mode 100644
index 00000000..61637051
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordExamplesTest.java
@@ -0,0 +1,38 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.Bean;
+import com.link_intersystems.beans.BeansFactory;
+import com.link_intersystems.beans.PropertyList;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class RecordExamplesTest {
+
+    @Test
+    void accessRecordProperties() {
+        BeansFactory beansFactory = BeansFactory.getInstance("record");
+        Bean<PersonRecord> bean = beansFactory.createBean(new PersonRecord("René", "Link"));
+        PropertyList properties = bean.getProperties();
+
+        assertEquals("René", properties.getByName("firstname").getValue());
+        assertEquals("Link", properties.getByName("lastname").getValue());
+    }
+
+    @Test
+    void copyRecordToJavaBean() {
+        BeansFactory recordBeansFactory = BeansFactory.getInstance("record");
+        PersonRecord personRecord = new PersonRecord("René", "Link");
+        Bean<PersonRecord> recordBean = recordBeansFactory.createBean(personRecord);
+
+        BeansFactory javaBeansFactory = BeansFactory.getInstance("java");
+        PersonBean personJavaBean = new PersonBean();
+        Bean<PersonBean> javaBean = javaBeansFactory.createBean(personJavaBean);
+
+        recordBean.getProperties().copy(javaBean.getProperties());
+
+
+        assertEquals("René", personJavaBean.getFirstname());
+        assertEquals("Link", personJavaBean.getLastname());
+    }
+}
diff --git a/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordPropertyDescTest.java b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordPropertyDescTest.java
new file mode 100644
index 00000000..3981d8ef
--- /dev/null
+++ b/lis-commons-beans-records/src/test/java/com/link_intersystems/beans/java/record/RecordPropertyDescTest.java
@@ -0,0 +1,61 @@
+package com.link_intersystems.beans.java.record;
+
+import com.link_intersystems.beans.BeanClass;
+import com.link_intersystems.beans.BeansFactory;
+import com.link_intersystems.beans.PropertyDesc;
+import com.link_intersystems.beans.PropertyWriteException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordPropertyDescTest {
+
+    private PropertyDesc propertyDesc;
+
+    @BeforeEach
+    void setUp() {
+        BeansFactory beansFactory = BeansFactory.getInstance("record");
+        BeanClass<PersonRecord> beanClass = beansFactory.createBeanClass(PersonRecord.class);
+        propertyDesc = beanClass.getAllProperties().getByName("firstname");
+    }
+
+    @Test
+    void getName() {
+        assertEquals("firstname", propertyDesc.getName());
+    }
+
+    @Test
+    void getType() {
+        assertEquals(String.class, propertyDesc.getType());
+    }
+
+    @Test
+    void isReadable() {
+        assertTrue(propertyDesc.isReadable());
+    }
+
+    @Test
+    void isWritable() {
+        assertFalse(propertyDesc.isWritable());
+    }
+
+    @Test
+    void getDeclaringClass() {
+        assertEquals(PersonRecord.class, propertyDesc.getDeclaringClass());
+    }
+
+    @Test
+    void getPropertyValue() {
+        PersonRecord personRecord = new PersonRecord("René", "Link");
+
+        assertEquals("René", propertyDesc.getPropertyValue(personRecord));
+    }
+
+    @Test
+    void setPropertyValue() {
+        PersonRecord personRecord = new PersonRecord("René", "Link");
+
+        assertThrows(PropertyWriteException.class, () -> propertyDesc.setPropertyValue(personRecord, "John"));
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans/pom.xml b/lis-commons-beans/pom.xml
index fdf8f143..91ddb5e0 100644
--- a/lis-commons-beans/pom.xml
+++ b/lis-commons-beans/pom.xml
@@ -1,4 +1,5 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.link-intersystems.commons</groupId>
@@ -23,6 +24,13 @@
             <artifactId>lis-commons-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-inline</artifactId>
+            <version>${mockito.version}</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <build>
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolveException.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolveException.java
new file mode 100644
index 00000000..a6691b26
--- /dev/null
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolveException.java
@@ -0,0 +1,19 @@
+package com.link_intersystems.beans;
+
+public class ArgumentResolveException extends Exception {
+
+    public ArgumentResolveException() {
+    }
+
+    public ArgumentResolveException(String message) {
+        super(message);
+    }
+
+    public ArgumentResolveException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ArgumentResolveException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolver.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolver.java
index 9792fa51..1803a824 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolver.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/ArgumentResolver.java
@@ -7,5 +7,39 @@
  */
 public interface ArgumentResolver {
 
-    public Object resolveArgument(Parameter parameter);
+    public static final ArgumentResolver NULL_INSTANCE = new ArgumentResolver() {
+        @Override
+        public boolean canResolveArgument(Parameter parameter) {
+            return false;
+        }
+
+        @Override
+        public Object resolveArgument(Parameter parameter) throws ArgumentResolveException {
+            return null;
+        }
+    };
+
+    default boolean canResolveArguments(Parameter[] parameters) {
+        for (int i = 0; i < parameters.length; i++) {
+            if (!canResolveArgument(parameters[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    boolean canResolveArgument(Parameter parameter);
+
+    default Object[] resolveArguments(Parameter[] parameters) throws ArgumentResolveException {
+        Object[] args = new Object[parameters.length];
+
+        for (int i = 0; i < parameters.length; i++) {
+            args[i] = resolveArgument(parameters[i]);
+        }
+
+        return args;
+    }
+
+    public Object resolveArgument(Parameter parameter) throws ArgumentResolveException;
 }
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanClass.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanClass.java
index 1bbfa11e..a7c7e92f 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanClass.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanClass.java
@@ -1,5 +1,6 @@
 package com.link_intersystems.beans;
 
+import java.lang.reflect.Parameter;
 import java.util.List;
 import java.util.function.Predicate;
 
@@ -33,11 +34,7 @@ public Bean<T> newBeanInstance() throws BeanInstantiationException {
         return beanInstanceFactory.newBeanInstance();
     }
 
-    public BeanInstanceFactory<T> getBeanInstanceFactory() {
-        return getBeanInstanceFactory(ad -> null);
-    }
-
-    public abstract BeanInstanceFactory<T> getBeanInstanceFactory(ArgumentResolver argumentResolver);
+    public abstract BeanInstanceFactory<T> getBeanInstanceFactory();
 
     /**
      * Returns a {@link Bean} based on the given bean instance.
@@ -67,6 +64,9 @@ public PropertyDescList getIndexedProperties() {
         return indexedProperties;
     }
 
+    /**
+     * @return the {@link #getProperties()} and the {@link #getIndexedProperties()}.
+     */
     public abstract PropertyDescList getAllProperties();
 
 
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstanceFactory.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstanceFactory.java
index 565cf59b..7087558a 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstanceFactory.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstanceFactory.java
@@ -5,7 +5,11 @@
  */
 public interface BeanInstanceFactory<T> {
 
-    public Bean<T> newBeanInstance();
+    default public Bean<T> newBeanInstance(){
+        return newBeanInstance(ArgumentResolver.NULL_INSTANCE);
+    }
+
+    public Bean<T> newBeanInstance(ArgumentResolver argumentResolver);
 
     public Bean<T> fromExistingInstance(T beanObject);
 }
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstantiationException.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstantiationException.java
index 8cd1b367..c6569589 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstantiationException.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/BeanInstantiationException.java
@@ -5,6 +5,10 @@
  */
 public class BeanInstantiationException extends RuntimeException {
 
+    public BeanInstantiationException(String message) {
+        super(message);
+    }
+
     public BeanInstantiationException(String message, Throwable cause) {
         super(message, cause);
     }
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/FilteredBeanClass.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/FilteredBeanClass.java
index 2c3bb572..3a3db40f 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/FilteredBeanClass.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/FilteredBeanClass.java
@@ -30,12 +30,12 @@ public Class<T> getType() {
 
 
     @Override
-    public BeanInstanceFactory<T> getBeanInstanceFactory(ArgumentResolver argumentResolver) {
-        BeanInstanceFactory<T> beanInstanceFactory = beanClass.getBeanInstanceFactory(argumentResolver);
+    public BeanInstanceFactory<T> getBeanInstanceFactory() {
+        BeanInstanceFactory<T> beanInstanceFactory = beanClass.getBeanInstanceFactory();
         return new BeanInstanceFactory<T>() {
             @Override
-            public Bean<T> newBeanInstance() {
-                Bean<T> bean = beanInstanceFactory.newBeanInstance();
+            public Bean<T> newBeanInstance(ArgumentResolver argumentResolver) {
+                Bean<T> bean = beanInstanceFactory.newBeanInstance(argumentResolver);
                 return new FilteredBean<>(FilteredBeanClass.this, bean, propertyFilter);
             }
 
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBean.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBean.java
index a360e164..1413e3ac 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBean.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBean.java
@@ -15,11 +15,12 @@
  */
 package com.link_intersystems.beans.java;
 
-import com.link_intersystems.beans.*;
+import com.link_intersystems.beans.Bean;
+import com.link_intersystems.beans.PropertyList;
 
 import java.util.List;
 
-import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.*;
 
 /**
  * A {@link JavaBean} is a wrapper for any java object that fulfills the <a href=
@@ -38,10 +39,11 @@ public class JavaBean<T> extends Bean<T> {
     private PropertyList propertyList;
     private List<JavaProperty> javaProperties;
 
-    JavaBean(JavaBeanClass<T> beanClass, T bean) {
+    protected JavaBean(JavaBeanClass<T> beanClass, T bean) {
         super(beanClass, bean);
     }
 
+
     /**
      * @return the {@link JavaBeanClass} of this {@link JavaBean}.
      */
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanClass.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanClass.java
index d2562b47..d6fe5966 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanClass.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanClass.java
@@ -19,12 +19,12 @@
 
 import java.beans.*;
 import java.io.Serializable;
-import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.util.List;
 
 import static java.text.MessageFormat.format;
 import static java.util.Arrays.stream;
+import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toList;
 
 /**
@@ -55,14 +55,22 @@ public class JavaBeanClass<T> extends BeanClass<T> implements Serializable {
     }
 
     JavaBeanClass(Class<T> beanType, Class<?> stopClass) throws BeanClassException {
+        this(getBeanInfo(beanType, stopClass));
+    }
+
+    private static BeanInfo getBeanInfo(Class<?> beanType, Class<?> stopClass) {
         try {
-            beanInfo = Introspector.getBeanInfo(beanType, stopClass);
+            return Introspector.getBeanInfo(beanType, stopClass);
         } catch (IntrospectionException e) {
             String msg = format("Unable to create BeanClass for ''{0}''. Stop at ''{1}''", beanType, stopClass);
             throw new BeanClassException(msg, e);
         }
     }
 
+    protected JavaBeanClass(BeanInfo beanInfo) throws BeanClassException {
+        this.beanInfo = requireNonNull(beanInfo);
+    }
+
     @Override
     public String getName() {
         return beanInfo.getBeanDescriptor().getName();
@@ -118,7 +126,7 @@ public boolean isPropertyAccessor(Method method) {
     }
 
     @Override
-    public BeanInstanceFactory<T> getBeanInstanceFactory(ArgumentResolver argumentResolver) {
+    public BeanInstanceFactory<T> getBeanInstanceFactory() {
         return new JavaBeanInstanceFactory<>(this);
     }
 
diff --git a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanInstanceFactory.java b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanInstanceFactory.java
index 93e08de0..c4f3fbf3 100644
--- a/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanInstanceFactory.java
+++ b/lis-commons-beans/src/main/java/com/link_intersystems/beans/java/JavaBeanInstanceFactory.java
@@ -1,6 +1,6 @@
 package com.link_intersystems.beans.java;
 
-import com.link_intersystems.beans.Bean;
+import com.link_intersystems.beans.ArgumentResolver;
 import com.link_intersystems.beans.BeanInstanceFactory;
 import com.link_intersystems.beans.BeanInstantiationException;
 
@@ -19,7 +19,7 @@ public class JavaBeanInstanceFactory<T> implements BeanInstanceFactory<T> {
     }
 
     @Override
-    public JavaBean<T> newBeanInstance() {
+    public JavaBean<T> newBeanInstance(ArgumentResolver argumentResolver) {
         Class<T> beanType = javaBeanClass.getType();
         try {
             Constructor<T> defaultConstructor = beanType.getDeclaredConstructor();
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolveExceptionTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolveExceptionTest.java
new file mode 100644
index 00000000..b80a96a1
--- /dev/null
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolveExceptionTest.java
@@ -0,0 +1,44 @@
+package com.link_intersystems.beans;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class ArgumentResolveExceptionTest {
+
+    @Test
+    void defaultConstructor() {
+        ArgumentResolveException exception = new ArgumentResolveException();
+
+        assertNull(exception.getMessage());
+        assertNull(exception.getCause());
+    }
+
+    @Test
+    void withMessage() {
+        ArgumentResolveException exception = new ArgumentResolveException("message");
+
+        assertEquals("message", exception.getMessage());
+        assertNull(exception.getCause());
+    }
+
+    @Test
+    void withMessageAndCause() {
+        Exception cause = new Exception();
+        ArgumentResolveException exception = new ArgumentResolveException("message", cause);
+
+        assertEquals("message", exception.getMessage());
+        assertEquals(cause, exception.getCause());
+    }
+
+    @Test
+    void withCause() {
+        Exception cause = new Exception();
+        ArgumentResolveException exception = new ArgumentResolveException(cause);
+
+        assertEquals("java.lang.Exception", exception.getMessage());
+        assertEquals(cause, exception.getCause());
+    }
+
+}
\ No newline at end of file
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolverTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolverTest.java
new file mode 100644
index 00000000..d6ba2cb9
--- /dev/null
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/ArgumentResolverTest.java
@@ -0,0 +1,59 @@
+package com.link_intersystems.beans;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Parameter;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class ArgumentResolverTest {
+
+    private ArgumentResolver argumentResolver;
+    private Parameter[] parameters;
+
+    @BeforeEach
+    void setUp() {
+        argumentResolver = spy(ArgumentResolver.class);
+        parameters = new Parameter[]{mock(Parameter.class), mock(Parameter.class)};
+    }
+
+    @Test
+    void canResolveArguments() {
+        when(argumentResolver.canResolveArgument(parameters[0])).thenReturn(true);
+        when(argumentResolver.canResolveArgument(parameters[1])).thenReturn(true);
+
+        assertTrue(argumentResolver.canResolveArguments(parameters));
+    }
+
+    @Test
+    void canNotResolveArguments() {
+        when(argumentResolver.canResolveArgument(parameters[0])).thenReturn(true);
+        when(argumentResolver.canResolveArgument(parameters[1])).thenReturn(false);
+
+        assertFalse(argumentResolver.canResolveArguments(parameters));
+    }
+
+    @Test
+    void resolveArguments() throws ArgumentResolveException {
+        when(argumentResolver.resolveArgument(parameters[0])).thenReturn("a");
+        when(argumentResolver.resolveArgument(parameters[1])).thenReturn("b");
+
+        Object[] args = argumentResolver.resolveArguments(parameters);
+
+        assertEquals("a", args[0]);
+        assertEquals("b", args[1]);
+    }
+
+    @Test
+    void argumentResolveException() throws ArgumentResolveException {
+        when(argumentResolver.resolveArgument(parameters[0])).thenReturn("a");
+        ArgumentResolveException are = new ArgumentResolveException();
+        when(argumentResolver.resolveArgument(parameters[1])).thenThrow(are);
+
+        ArgumentResolveException thrownException = assertThrows(ArgumentResolveException.class, () -> argumentResolver.resolveArguments(parameters));
+
+        assertEquals(are, thrownException);
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstanceFactoryTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstanceFactoryTest.java
new file mode 100644
index 00000000..913b6655
--- /dev/null
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstanceFactoryTest.java
@@ -0,0 +1,17 @@
+package com.link_intersystems.beans;
+
+import org.junit.jupiter.api.Test;
+
+import static org.mockito.Mockito.*;
+
+class BeanInstanceFactoryTest {
+
+    @Test
+    void newBeanInstance() {
+        BeanInstanceFactory beanInstanceFactory = spy(BeanInstanceFactory.class);
+
+        beanInstanceFactory.newBeanInstance();
+
+        verify(beanInstanceFactory, times(1)).newBeanInstance(ArgumentResolver.NULL_INSTANCE);
+    }
+}
\ No newline at end of file
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstantiationExceptionTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstantiationExceptionTest.java
new file mode 100644
index 00000000..4e1b9e71
--- /dev/null
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/BeanInstantiationExceptionTest.java
@@ -0,0 +1,25 @@
+package com.link_intersystems.beans;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class BeanInstantiationExceptionTest {
+
+    @Test
+    void withMessage() {
+        BeanInstantiationException exception = new BeanInstantiationException("a message");
+
+        assertEquals("a message", exception.getMessage());
+    }
+
+    @Test
+    void withMessageAndCause() {
+        Exception cause = new Exception();
+        BeanInstantiationException exception = new BeanInstantiationException("a message", cause);
+
+        assertEquals("a message", exception.getMessage());
+        assertEquals(cause, exception.getCause());
+    }
+
+}
\ No newline at end of file
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanClassTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanClassTest.java
index 1aa51c23..592074e3 100644
--- a/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanClassTest.java
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanClassTest.java
@@ -4,7 +4,7 @@
 import com.link_intersystems.beans.BeanInstantiationException;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * @author René Link {@literal <rene.link@link-intersystems.com>}
@@ -22,4 +22,10 @@ void newBeanInstance() {
         BeanClass<UninstantiableBean> javaBeanClass = new JavaBeanClass<>(UninstantiableBean.class);
         assertThrows(BeanInstantiationException.class, javaBeanClass::newBeanInstance);
     }
+
+    @Test
+    void getName() {
+        BeanClass<SomeBean> javaBeanClass = new JavaBeanClass<>(SomeBean.class);
+        assertEquals("SomeBean", javaBeanClass.getName());
+    }
 }
\ No newline at end of file
diff --git a/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanInstanceFactoryTest.java b/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanInstanceFactoryTest.java
index 6323f16e..580e3e7e 100644
--- a/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanInstanceFactoryTest.java
+++ b/lis-commons-beans/src/test/java/com/link_intersystems/beans/java/JavaBeanInstanceFactoryTest.java
@@ -4,8 +4,7 @@
 import com.link_intersystems.beans.BeanInstantiationException;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * @author René Link {@literal <rene.link@link-intersystems.com>}
@@ -22,6 +21,17 @@ void newBeanInstance() {
         assertNotNull(someBeanBean.getBeanObject());
     }
 
+    @Test
+    void fromExistingBean() {
+        JavaBeanInstanceFactory<SomeBean> beanInstanceFactory = new JavaBeanInstanceFactory<>(new JavaBeanClass<>(SomeBean.class));
+
+        SomeBean bean = new SomeBean();
+        Bean<SomeBean> someBeanBean = beanInstanceFactory.fromExistingInstance(bean);
+
+        assertNotNull(someBeanBean);
+        assertEquals(bean, someBeanBean.getBeanObject());
+    }
+
     @Test
     void newBeanInstanceException() {
         class UninstantiableBean {
diff --git a/pom.xml b/pom.xml
index ddd5e0f6..f6d0bf44 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
@@ -37,6 +38,7 @@
         <module>lis-commons-swing</module>
         <module>lis-commons-io</module>
         <module>lis-commons-security</module>
+        <module>lis-commons-beans-records</module>
     </modules>
 
     <properties>
@@ -138,6 +140,11 @@
                 <artifactId>lis-commons-beans</artifactId>
                 <version>1.9.7-SNAPSHOT</version>
             </dependency>
+            <dependency>
+                <groupId>com.link-intersystems.commons</groupId>
+                <artifactId>lis-commons-beans-records</artifactId>
+                <version>1.9.7-SNAPSHOT</version>
+            </dependency>
             <dependency>
                 <groupId>com.link-intersystems.commons</groupId>
                 <artifactId>lis-commons-beans</artifactId>