Great Idea: Property Annotations alternative to getter/setters

Question

Currently, a huge amount of Java objects use property fields with getter/setter accessors:
class MyClass
     protected int xyz;
     public int getXyz() {
          return xyz;
     public int setXyz(int xyz) {
          this.xyz = xyz;
}.NET uses a slightly simpler syntax which internally generates getter/setter methods:
class MyClass
     protected int xyz;
     public int Xyz {
          get {
               return xyz;
          set {
               xyz = value;
}Most of the time (90%+), the getters and setters just set/return. Of course, there are times where it's necessary to implement additional logic without changing the interface presented to other classes. However, there are lots of cases where there is huge amounts of trivial getter/setter code. Also, it takes effort to maintain the getters/setters, when fields are added, deleted, or renamed.
Wouldn't it be much nicer to have trivial getters/setters implied via annotations? Instead of the above examples, do:
class MyClass
     // defaults to providing both getter and setter.
     @PublicProperty
     protected int xyz;
}You could have variants for protected access, private access, and parameters for getter only or setter only. And, you would continue to use the traditional syntax when you want to do non-trivial getter/setter logic.
The big advantage is that this syntax would be much easier to maintain. Much less code to scroll through. Much easier to rename fields. Easier to delete fields. Easier to add new fields without relying on IDE "generate getter/setter" features.
What does everyone think?

Answer 1

MelGohan + dizzy,
Java Beans and every library and framework built on top of Java Beans (such as JSF and EJB 3.0) require getters/setters; they aren't an optional design consideration. I could avoid such libraries entirely, but that is extreme.
aconst_null + YAT,
Interesting point about annotation limitations. However, Java Beans based frameworks such as JSF and EJB 3.0 could have support for such annotations. For example, in JSF, when you use {#bean.property}, the framework could check for getProperty()/setProperty() or check for an annotated instance variable named "property".
Or maybe there should be a language level solution to this rather than an annotation-based patch. Any time there is a large volume of rubber stamp code like this, there is probably a better design.